Merge pull request #185 from onevcat/feature/cancel-api-on-image-view

Cancel downloading api on image view

Kingfisher-Demo/ViewController.swift

@@ -55,6 +55,12 @@ extension ViewController {
         return 10
     }
     
+    override func collectionView(collectionView: UICollectionView, didEndDisplayingCell cell: UICollectionViewCell, forItemAtIndexPath indexPath: NSIndexPath) {
+        
+        // This will cancel all unfinished downloading task when the cell disappearing.
+        (cell as! CollectionViewCell).cellImageView.kf_cancelDownloadTask()
+    }
+    
     override func collectionView(collectionView: UICollectionView, cellForItemAtIndexPath indexPath: NSIndexPath) -> UICollectionViewCell {
         // swiftlint:disable force_cast
         let cell = collectionView.dequeueReusableCellWithReuseIdentifier("collectionViewCell", forIndexPath: indexPath) as! CollectionViewCell

Kingfisher/UIImageView+Kingfisher.swift

@@ -187,6 +187,7 @@ public extension UIImageView {
         image = placeholderImage
         
         kf_setWebURL(resource.downloadURL)
+        
         let task = KingfisherManager.sharedManager.retrieveImageWithResource(resource, optionsInfo: optionsInfo,
             progressBlock: { receivedSize, totalSize in
                 if let progressBlock = progressBlock {
@@ -199,10 +200,21 @@ public extension UIImageView {
             completionHandler: {[weak self] image, error, cacheType, imageURL in
                 
                 dispatch_async_safely_main_queue {
-                    if let sSelf = self where imageURL == sSelf.kf_webURL && image != nil {
-                        
-                        if let transitionItem = optionsInfo?.kf_firstMatchIgnoringAssociatedValue(.Transition(.None)),
-                            case .Transition(let transition) = transitionItem where cacheType == .None {
+                    
+                    guard let sSelf = self where imageURL == sSelf.kf_webURL else {
+                        completionHandler?(image: image, error: error, cacheType: cacheType, imageURL: imageURL)
+                        return
+                    }
+                    
+                    sSelf.kf_setImageTask(nil)
+                    
+                    guard let image = image else {
+                        completionHandler?(image: nil, error: error, cacheType: cacheType, imageURL: imageURL)
+                        return
+                    }
+                    
+                    if let transitionItem = optionsInfo?.kf_firstMatchIgnoringAssociatedValue(.Transition(.None)),
+                        case .Transition(let transition) = transitionItem where cacheType == .None {
                             
                             UIView.transitionWithView(sSelf, duration: 0.0, options: [],
                                 animations: {
@@ -212,7 +224,7 @@ public extension UIImageView {
                                     UIView.transitionWithView(sSelf, duration: transition.duration,
                                         options: transition.animationOptions,
                                         animations: {
-                                            transition.animations?(sSelf, image!)
+                                            transition.animations?(sSelf, image)
                                         },
                                         completion: { finished in
                                             transition.completion?(finished)
@@ -221,18 +233,17 @@ public extension UIImageView {
                                     )
                                 }
                             )
-                        } else {
-                            indicator?.stopAnimating()
-                            sSelf.image = image
-                            completionHandler?(image: image, error: error, cacheType: cacheType, imageURL: imageURL)
-                        }
                     } else {
+                        indicator?.stopAnimating()
+                        sSelf.image = image
                         completionHandler?(image: image, error: error, cacheType: cacheType, imageURL: imageURL)
                     }
                 }
             }
         )
         
+        kf_setImageTask(task)
+        
         return task
     }
     
@@ -262,10 +273,21 @@ public extension UIImageView {
     }
 }
 
+extension UIImageView {
+    /**
+     Cancel the image download task bounded to the image view if it is running.
+     Nothing will happen if the downloading has already finished.
+     */
+    public func kf_cancelDownloadTask() {
+        kf_imageTask?.downloadTask?.cancel()
+    }
+}
+
 // MARK: - Associated Object
 private var lastURLKey: Void?
 private var indicatorKey: Void?
 private var showIndicatorWhenLoadingKey: Void?
+private var imageTaskKey: Void?
 
 public extension UIImageView {
     /// Get the image URL binded to this image view.
@@ -327,6 +349,14 @@ public extension UIImageView {
     private func kf_setIndicator(indicator: UIActivityIndicatorView?) {
         objc_setAssociatedObject(self, &indicatorKey, indicator, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
     }
+    
+    private var kf_imageTask: RetrieveImageTask? {
+        return objc_getAssociatedObject(self, &imageTaskKey) as? RetrieveImageTask
+    }
+    
+    private func kf_setImageTask(task: RetrieveImageTask?) {
+        objc_setAssociatedObject(self, &imageTaskKey, task, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
+    }
 }
 
 // MARK: - Deprecated

KingfisherTests/UIImageViewExtensionTests.swift

@@ -96,6 +96,8 @@ class UIImageViewExtensionTests: XCTestCase {
         
         var progressBlockIsCalled = false
         
+        cleanDefaultCache()
+        
         imageView.kf_setImageWithResource(resource, placeholderImage: nil, optionsInfo: nil, progressBlock: { (receivedSize, totalSize) -> () in
             progressBlockIsCalled = true
             }) { (image, error, cacheType, imageURL) -> () in
@@ -107,7 +109,7 @@ class UIImageViewExtensionTests: XCTestCase {
                 XCTAssert(self.imageView.image! == testImage, "Downloaded image should be already set to the image property.")
                 XCTAssert(self.imageView.kf_webURL == imageURL, "Web URL should equal to the downloaded url.")
                 
-                XCTAssert(cacheType == .None, "The cache type should be none here. This image was just downloaded.")
+                XCTAssert(cacheType == .None, "The cache type should be none here. This image was just downloaded. But now is: \(cacheType)")
         }
         
         waitForExpectationsWithTimeout(5, handler: nil)
@@ -387,4 +389,67 @@ class UIImageViewExtensionTests: XCTestCase {
         
         waitForExpectationsWithTimeout(5, handler: nil)
     }
+    
+    func testCacnelImageTask() {
+        let expectation = expectationWithDescription("wait for downloading image")
+        
+        let URLString = testKeys[0]
+        let stub = stubRequest("GET", URLString).andReturn(200).withBody(testImageData).delay()
+        let URL = NSURL(string: URLString)!
+        
+        imageView.kf_setImageWithURL(URL, placeholderImage: nil, optionsInfo: nil, progressBlock: { (receivedSize, totalSize) -> () in
+                XCTFail("Progress block should not be called.")
+            }) { (image, error, cacheType, imageURL) -> () in
+                XCTAssertNotNil(error)
+                XCTAssertEqual(error?.code, NSURLErrorCancelled)
+                
+                expectation.fulfill()
+        }
+        
+        dispatch_after(dispatch_time(DISPATCH_TIME_NOW, Int64(Double(NSEC_PER_SEC) * 0.1)), dispatch_get_main_queue()) { () -> Void in
+            self.imageView.kf_cancelDownloadTask()
+            stub.go()
+        }
+        
+        waitForExpectationsWithTimeout(5, handler: nil)
+    }
+    
+    func testDownloadForMutipleURLs() {
+        let expectation = expectationWithDescription("wait for downloading image")
+        
+        let URLStrings = [testKeys[0], testKeys[1]]
+        stubRequest("GET", URLStrings[0]).andReturn(200).withBody(testImageData)
+        stubRequest("GET", URLStrings[1]).andReturn(200).withBody(testImageData)
+        let URLs = URLStrings.map{NSURL(string: $0)!}
+        
+        var task1Complete = false
+        var task2Complete = false
+        
+        imageView.kf_setImageWithURL(URLs[0], placeholderImage: nil, optionsInfo: nil, progressBlock: { (receivedSize, totalSize) -> () in
+            
+            }) { (image, error, cacheType, imageURL) -> () in
+                task1Complete = true
+                XCTAssertNotNil(image)
+                XCTAssertEqual(imageURL, URLs[0])
+                XCTAssertNotEqual(self.imageView.image, image)
+        }
+        
+        self.imageView.kf_setImageWithURL(URLs[1], placeholderImage: nil, optionsInfo: nil, progressBlock: { (receivedSize, totalSize) -> () in
+            
+            }) { (image, error, cacheType, imageURL) -> () in
+                task2Complete = true
+                XCTAssertNotNil(image)
+                XCTAssertEqual(imageURL, URLs[1])
+                XCTAssertEqual(self.imageView.image, image)
+        }
+        
+        dispatch_after(dispatch_time(DISPATCH_TIME_NOW, Int64(Double(NSEC_PER_SEC) * 0.1)), dispatch_get_main_queue()) { () -> Void in
+            XCTAssertTrue(task1Complete, "Task 1 should be completed.")
+            XCTAssertTrue(task2Complete, "Task 2 should be completed.")
+
+            expectation.fulfill()
+        }
+        
+        waitForExpectationsWithTimeout(5, handler: nil)
+    }
 }