Merge pull request #77 from vfn/issue-70

Scale factor and default options

Kingfisher/ImageCache.swift

@@ -246,7 +246,7 @@ extension ImageCache {
                 //Found image in memory cache.
                 if options.shouldDecode {
                     dispatch_async(self.processQueue, { () -> Void in
-                        let result = image.kf_decodedImage()
+                        let result = image.kf_decodedImage(scale: options.scale)
                         dispatch_async(options.queue, { () -> Void in
                             completionHandler?(result, .Memory)
                             return
@@ -259,11 +259,11 @@ extension ImageCache {
                 //Begin to load image from disk
                 dispatch_async(self.ioQueue, { () -> Void in
                     
-                    if let image = self.retrieveImageInDiskCacheForKey(key) {
+                    if let image = self.retrieveImageInDiskCacheForKey(key, scale: options.scale) {
                         
                         if options.shouldDecode {
                             dispatch_async(self.processQueue, { () -> Void in
-                                let result = image.kf_decodedImage()
+                                let result = image.kf_decodedImage(scale: options.scale)
                                 self.storeImage(result!, forKey: key, toDisk: false, completionHandler: nil)
                                 
                                 dispatch_async(options.queue, { () -> Void in
@@ -310,11 +310,12 @@ extension ImageCache {
     Get an image for a key from disk.
     
     :param: key Key for the image.
+    :param: scale The scale factor to assume when interpreting the image data.
     
     :returns: The image object if it is cached, or `nil` if there is no such key in the cache.
     */
-    public func retrieveImageInDiskCacheForKey(key: String) -> UIImage? {
-        return diskImageForKey(key)
+    public func retrieveImageInDiskCacheForKey(key: String, scale: CGFloat = KingfisherManager.DefaultOptions.scale) -> UIImage? {
+        return diskImageForKey(key, scale: scale)
     }
 }
 
@@ -595,9 +596,9 @@ public extension ImageCache {
 // MARK: - Internal Helper
 extension ImageCache {
     
-    func diskImageForKey(key: String) -> UIImage? {
+    func diskImageForKey(key: String, scale: CGFloat) -> UIImage? {
         if let data = diskImageDataForKey(key) {
-            if let image = UIImage(data: data) {
+            if let image = UIImage(data: data, scale: scale) {
                 return image
             } else {
                 return nil

Kingfisher/ImageDownloader.swift

@@ -78,6 +78,7 @@ public class ImageDownloader: NSObject {
         var callbacks = [CallbackPair]()
         var responseData = NSMutableData()
         var shouldDecode = false
+        var scale = KingfisherManager.DefaultOptions.scale
     }
     
     // MARK: - Public property
@@ -146,7 +147,7 @@ public extension ImageDownloader {
                            progressBlock: ImageDownloaderProgressBlock?,
                        completionHandler: ImageDownloaderCompletionHandler?)
     {
-        downloadImageWithURL(URL, options: KingfisherManager.OptionsNone, progressBlock: progressBlock, completionHandler: completionHandler)
+        downloadImageWithURL(URL, options: KingfisherManager.DefaultOptions, progressBlock: progressBlock, completionHandler: completionHandler)
     }
     
     /**
@@ -196,6 +197,7 @@ public extension ImageDownloader {
             task.resume()
             
             fetchLoad.shouldDecode = options.shouldDecode
+            fetchLoad.scale = options.scale
             
             retrieveImageTask?.downloadTask = task
         }
@@ -285,12 +287,12 @@ extension ImageDownloader: NSURLSessionDataDelegate {
                 dispatch_async(processQueue, { () -> Void in
                     
                     if let fetchLoad = self.fetchLoadForKey(URL) {
-                        if let image = UIImage(data: fetchLoad.responseData) {
+                        if let image = UIImage(data: fetchLoad.responseData, scale: fetchLoad.scale) {
                             
                             self.delegate?.imageDownloader?(self, didDownloadImage: image, forURL: URL, withResponse: task.response!)
                             
                             if fetchLoad.shouldDecode {
-                                self.callbackWithImage(image.kf_decodedImage(), error: nil, imageURL: URL)
+                                self.callbackWithImage(image.kf_decodedImage(scale: fetchLoad.scale), error: nil, imageURL: URL)
                             } else {
                                 self.callbackWithImage(image, error: nil, imageURL: URL)
                             }

Kingfisher/KingfisherManager.swift

@@ -65,13 +65,16 @@ public class KingfisherManager {
     /**
     *	Options to control some downloader and cache behaviors.
     */
-    public typealias Options = (forceRefresh: Bool, lowPriority: Bool, cacheMemoryOnly: Bool, shouldDecode: Bool, queue: dispatch_queue_t!)
+    public typealias Options = (forceRefresh: Bool, lowPriority: Bool, cacheMemoryOnly: Bool, shouldDecode: Bool, queue: dispatch_queue_t!, scale: CGFloat)
     
     /// A preset option tuple with all value set to `false`.
-    public static var OptionsNone: Options = {
-        return (forceRefresh: false, lowPriority: false, cacheMemoryOnly: false, shouldDecode: false, queue: dispatch_get_main_queue())
+    public static let OptionsNone: Options = {
+        return (forceRefresh: false, lowPriority: false, cacheMemoryOnly: false, shouldDecode: false, queue: dispatch_get_main_queue(), scale: 1.0)
     }()
     
+    /// The default set of options to be used by the manager to control some downloader and cache behaviors.
+    public static var DefaultOptions: Options = OptionsNone
+    
     /// Shared manager used by the extensions across Kingfisher.
     public class var sharedManager: KingfisherManager {
         return instance
@@ -114,18 +117,16 @@ public class KingfisherManager {
         func parseOptionsInfo(optionsInfo: KingfisherOptionsInfo?) -> (Options, ImageCache, ImageDownloader) {
             let options: Options
             if let optionsInOptionsInfo = optionsInfo?[.Options] as? KingfisherOptions {
-                options = (forceRefresh: (optionsInOptionsInfo & KingfisherOptions.ForceRefresh) != KingfisherOptions.None,
-                    lowPriority: (optionsInOptionsInfo & KingfisherOptions.LowPriority) != KingfisherOptions.None,
-                    cacheMemoryOnly: (optionsInOptionsInfo & KingfisherOptions.CacheMemoryOnly) != KingfisherOptions.None,
-                    shouldDecode: (optionsInOptionsInfo & KingfisherOptions.BackgroundDecode) != KingfisherOptions.None,
-                    queue: dispatch_get_main_queue())
+                let queue = (optionsInOptionsInfo & .BackgroundCallback) != .None ? dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0) : KingfisherManager.DefaultOptions.queue
+                let scale = (optionsInOptionsInfo & .ScreenScale) != .None ? UIScreen.mainScreen().scale : KingfisherManager.DefaultOptions.scale
+                options = (forceRefresh: (optionsInOptionsInfo & .ForceRefresh) != .None,
+                    lowPriority: (optionsInOptionsInfo & .LowPriority) != .None,
+                    cacheMemoryOnly: (optionsInOptionsInfo & .CacheMemoryOnly) != .None,
+                    shouldDecode: (optionsInOptionsInfo & .BackgroundDecode) != .None,
+                    queue: queue,
+                    scale: scale)
             } else {
-                options = (forceRefresh: false,
-                    lowPriority: false,
-                    cacheMemoryOnly: false,
-                    shouldDecode: false,
-                    queue: dispatch_get_main_queue()
-                    )
+                options = KingfisherManager.DefaultOptions
             }
             
             let targetCache = optionsInfo?[.TargetCache] as? ImageCache ?? self.cache

Kingfisher/KingfisherOptions.swift

@@ -77,4 +77,10 @@ public struct KingfisherOptions : RawOptionSetType {
     
     /// Cache the downloaded image to Apple Watch app. By default the downloaded image will not be cached in the watch. By containing this in options could improve performance when setting the same URL later. However, the cache size in the Watch is limited. So you will want to cache often used images only.
     public static var CacheInWatch: KingfisherOptions { return KingfisherOptions(1 << 4) }
+    
+    /// If set it will dispatch callbacks asynchronously to the global queue DISPATCH_QUEUE_PRIORITY_DEFAULT. Otherwise it will use the queue defined at KingfisherManager.DefaultOptions.queue
+    public static var BackgroundCallback: KingfisherOptions { return KingfisherOptions(1 << 5) }
+    
+    /// Decode the image using the same scale as the main screen. Otherwise it will use the same scale as defined on the KingfisherManager.DefaultOptions.scale.
+    public static var ScreenScale: KingfisherOptions { return KingfisherOptions(1 << 6) }
 }

Kingfisher/UIImage+Decode.swift

@@ -28,6 +28,10 @@ import Foundation
 
 extension UIImage {
     func kf_decodedImage() -> UIImage? {
+        return self.kf_decodedImage(scale: self.scale)
+    }
+    
+    func kf_decodedImage(#scale: CGFloat) -> UIImage? {
         let imageRef = self.CGImage
         let colorSpace = CGColorSpaceCreateDeviceRGB()
         let bitmapInfo = CGBitmapInfo(CGImageAlphaInfo.PremultipliedLast.rawValue)
@@ -36,7 +40,7 @@ extension UIImage {
             let rect = CGRectMake(0, 0, CGFloat(CGImageGetWidth(imageRef)), CGFloat(CGImageGetHeight(imageRef)))
             CGContextDrawImage(context, rect, imageRef)
             let decompressedImageRef = CGBitmapContextCreateImage(context)
-            return UIImage(CGImage: decompressedImageRef)
+            return UIImage(CGImage: decompressedImageRef, scale: scale, orientation: self.imageOrientation)
         } else {
             return nil
         }