Kingfisher 源码分析

let url = URL(string: "url_of_your_image")
imageView.kf.setImage(with: url)

public final class Kingfisher<Base> {
    public let base: Base
    public init(_ base: Base) {
        self.base = base
    }
}

public protocol KingfisherCompatible {
    associatedtype CompatibleType
    var kf: CompatibleType { get }
}

public extension KingfisherCompatible {
    public var kf: Kingfisher<Self> {
        return Kingfisher(self)
    }
}

extension Image: KingfisherCompatible { }
extension ImageView: KingfisherCompatible { }
extension Button: KingfisherCompatible { }

extension Kingfisher where Base: ImageView {
	...
}

/**
     Set an image with a resource, a placeholder image, options, progress handler and completion handler.
     
     - parameter resource:          Resource object contains information such as `cacheKey` and `downloadURL`.
     - parameter placeholder:       A placeholder image when retrieving the image at URL.
     - parameter options:           A dictionary could control some behaviors. See `KingfisherOptionsInfo` for more.
     - parameter progressBlock:     Called when the image downloading progress gets updated.
     - parameter completionHandler: Called when the image retrieved and set.
     
     - returns: A task represents the retrieving process.
*/
    @discardableResult
    public func setImage(with resource: Resource?,
                         placeholder: Placeholder? = nil,
                         options: KingfisherOptionsInfo? = nil,
                         progressBlock: DownloadProgressBlock? = nil,
                         completionHandler: CompletionHandler? = nil) -> RetrieveImageTask 

public protocol Resource {
    /// The key used in cache.
    var cacheKey: String { get }
    
    /// The target image URL.
    var downloadURL: URL { get }
}

guard let resource = resource else {
    self.placeholder = placeholder
    setWebURL(nil)
    completionHandler?(nil, nil, .none, nil)
    return .empty
}

setWebURL(resource.downloadURL)

public protocol Placeholder {
    
    /// How the placeholder should be added to a given image view.
    func add(to imageView: ImageView)
    
    /// How the placeholder should be removed from a given image view.
    func remove(from imageView: ImageView)
}

if !options.keepCurrentImageWhileLoading || noImageOrPlaceholderSet {
// Always set placeholder while there is no image/placeholder yet.
    self.placeholder = placeholder
}

var options = KingfisherManager.shared.defaultOptions + (options ?? KingfisherEmptyOptionsInfo)

func retrieveImage(with resource: Resource,
        options: KingfisherOptionsInfo?,
        progressBlock: DownloadProgressBlock?,
        completionHandler: CompletionHandler?) -> RetrieveImageTask

DispatchQueue.main.safeAsync {
    ...
    strongBase.image = image
    ...
}

// This method will dispatch the `block` to self.
// If `self` is the main queue, and current thread is main thread, the block
// will be invoked immediately instead of being dispatched.
func safeAsync(_ block: @escaping ()->()) {
    if self === DispatchQueue.main && Thread.isMainThread {
        block()
    } else {
        async { block() }
    }
}

func downloadAndCacheImage(with url: URL,
                             forKey key: String,
                      retrieveImageTask: RetrieveImageTask,
                          progressBlock: DownloadProgressBlock?,
                      completionHandler: CompletionHandler?,
                                options: KingfisherOptionsInfo) -> RetrieveImageDownloadTask?

if let error = error, error.code == KingfisherError.notModified.rawValue {
    // Not modified. Try to find the image from cache.
    // (The image should be in cache. It should be guaranteed by the framework users.)
    targetCache.retrieveImage(forKey: key, options: options, completionHandler: { (cacheImage, cacheType) -> Void in
        completionHandler?(cacheImage, nil, cacheType, url)
    })
    return
}

open func store(_ image: Image,
                      original: Data? = nil,
                      forKey key: String,
                      processorIdentifier identifier: String = "",
                      cacheSerializer serializer: CacheSerializer = DefaultCacheSerializer.default,
                      toDisk: Bool = true,
                      completionHandler: (() -> Void)? = nil)

func tryToRetrieveImageFromCache(forKey key: String,
                                       with url: URL,
                              retrieveImageTask: RetrieveImageTask,
                                  progressBlock: DownloadProgressBlock?,
                              completionHandler: CompletionHandler?,
                                        options: KingfisherOptionsInfo)

let diskTaskCompletionHandler: CompletionHandler = { (image, error, cacheType, imageURL) -> Void in
            completionHandler?(image, error, cacheType, imageURL)
}

func retrieveImage(forKey key: String,
                               options: KingfisherOptionsInfo?,
                     completionHandler: ((Image?, CacheType) -> Void)?) -> RetrieveImageDiskTask?

if image != nil {
    diskTaskCompletionHandler(image, nil, cacheType, url)
    return
}

let processor = options.processor
    guard processor != DefaultImageProcessor.default else {
    handleNoCache()
    return
}

let originalCache = options.originalCache ?? targetCache
let optionsWithoutProcessor = options.removeAllMatchesIgnoringAssociatedValue(.processor(processor))
originalCache.retrieveImage(forKey: key, options: optionsWithoutProcessor) { image, cacheType in
    // If we found the original image, there is no need to download it again.
    // We could just apply processor to it now.
    guard let image = image else {
        handleNoCache()
        return
    }

    processQueue.async {
        guard let processedImage = processor.process(item: .image(image), options: options) else {
        options.callbackDispatchQueue.safeAsync {
            diskTaskCompletionHandler(nil, nil, .none, url)
        }
        return
    }
    targetCache.store(processedImage,
                      original: nil,
                      forKey: key,
                      processorIdentifier:options.processor.identifier,
                      cacheSerializer: options.cacheSerializer,
                      toDisk: !options.cacheMemoryOnly,
                      completionHandler: {
                          guard options.waitForCache else { return }

                          let cacheType = targetCache.imageCachedType(forKey: key, processorIdentifier: options.processor.identifier)
                              options.callbackDispatchQueue.safeAsync {
                                  diskTaskCompletionHandler(processedImage, nil, cacheType, url)
                              }
    })

    if options.waitForCache == false {
        options.callbackDispatchQueue.safeAsync {
            diskTaskCompletionHandler(processedImage, nil, .none, url)
        }
    }
}

func retrieveImage(forKey key: String,
                   options: KingfisherOptionsInfo?,
                   completionHandler: ((Image?, CacheType) -> Void)?) -> RetrieveImageDiskTask?

if let image = self.retrieveImageInMemoryCache(forKey: key, options: options) {
    options.callbackDispatchQueue.safeAsync {
        completionHandler(imageModifier.modify(image), .memory)
    }
} else if options.fromMemoryCacheOrRefresh { // Only allows to get images from memory cache.
    options.callbackDispatchQueue.safeAsync {
        completionHandler(nil, .none)
    }
}

var sSelf: ImageCache! = self
block = DispatchWorkItem(block: {
    // Begin to load image from disk
    if let image = sSelf.retrieveImageInDiskCache(forKey: key, options: options) {
        if options.backgroundDecode {
            sSelf.processQueue.async {

                let result = image.kf.decoded
                            
                sSelf.store(result,
                            forKey: key,
                            processorIdentifier: options.processor.identifier,
                            cacheSerializer: options.cacheSerializer,
                            toDisk: false,
                            completionHandler: nil)
                            options.callbackDispatchQueue.safeAsync {
                                completionHandler(imageModifier.modify(result), .disk)
                                sSelf = nil
                }
            }
        } else {
            sSelf.store(image,
                        forKey: key,
                        processorIdentifier: options.processor.identifier,
                        cacheSerializer: options.cacheSerializer,
                        toDisk: false,
                        completionHandler: nil
            )
            options.callbackDispatchQueue.safeAsync {
                completionHandler(imageModifier.modify(image), .disk)
                sSelf = nil
            }
        }
    } else {
        // No image found from either memory or disk
        // 没找到就返回 nil
        options.callbackDispatchQueue.safeAsync {
            completionHandler(nil, .none)
            sSelf = nil
        }
    }
})
            
sSelf.ioQueue.async(execute: block!)

fileprivate func travelCachedFiles(onlyForCacheSize: Bool) -> (urlsToDelete: [URL], diskCacheSize: UInt, cachedFiles: [URL: URLResourceValues])

for fileURL in URLsToDelete {
    do {
        try self.fileManager.removeItem(at: fileURL)
    } catch _ { }
}

// 设定目标size为最大的一半
let targetSize = self.maxDiskCacheSize / 2
                    
// Sort files by last modify date. We want to clean from the oldest files.
// 先对文件进行时间排序
let sortedFiles = cachedFiles.keysSortedByValue {
    resourceValue1, resourceValue2 -> Bool in
                    
    if let date1 = resourceValue1.contentAccessDate,
       let date2 = resourceValue2.contentAccessDate
       {
           return date1.compare(date2) == .orderedAscending
       }
                    
       // Not valid date information. This should not happen. Just in case.
       return true
    }
    // 然后遍历文件数组进行删除，从最老的文件往前删除，直到磁盘缓存空间小于目标空间            
    for fileURL in sortedFiles {
                    
        do {
            try self.fileManager.removeItem(at: fileURL)
        } catch { }
                        
        URLsToDelete.append(fileURL)
                    
        if let fileSize = cachedFiles[fileURL]?.totalFileAllocatedSize {
            diskCacheSize -= UInt(fileSize)
        }
                    
        if diskCacheSize < targetSize {
            break
}

DispatchQueue.main.async {
                
    if URLsToDelete.count != 0 {
        let cleanedHashes = URLsToDelete.map { $0.lastPathComponent }
        NotificationCenter.default.post(name: .KingfisherDidCleanDiskCache, object: self, userInfo: [KingfisherDiskCacheCleanedHashKey: cleanedHashes])
                }
                
        handler?()
}

class ImageFetchLoad {
    var contents = [(callback: CallbackPair, options: KingfisherOptionsInfo)]()
    var responseData = NSMutableData()

    var downloadTaskCount = 0
    var downloadTask: RetrieveImageDownloadTask?
    var cancelSemaphore: DispatchSemaphore?
}

open func downloadImage(with url: URL,
                       retrieveImageTask: RetrieveImageTask? = nil,
                       options: KingfisherOptionsInfo? = nil,
                       progressBlock: ImageDownloaderProgressBlock? = nil,
                       completionHandler: ImageDownloaderCompletionHandler? = nil) -> RetrieveImageDownloadTask?

// We need to set the URL as the load key. So before setup progress, we need to ask the `requestModifier` for a final URL.
var request = URLRequest(url: url, cachePolicy: .reloadIgnoringLocalCacheData, timeoutInterval: timeout)
request.httpShouldUsePipelining = requestsUsePipelining

if let modifier = options?.modifier {
    guard let r = modifier.modified(for: request) else {
        completionHandler?(nil, NSError(domain: KingfisherErrorDomain, code: KingfisherError.downloadCancelledBeforeStarting.rawValue, userInfo: nil), nil, nil)
        return nil
    }
    request = r
}
        
// There is a possibility that request modifier changed the url to `nil` or empty.
guard let url = request.url, !url.absoluteString.isEmpty else {
    completionHandler?(nil, NSError(domain: KingfisherErrorDomain, code: KingfisherError.invalidURL.rawValue, userInfo: nil), nil, nil)
    return nil
}

fetchLoad.downloadTaskCount += 1

private func cleanFetchLoad(for url: URL) {
    guard let downloader = downloadHolder else {
        return
    }

    downloader.barrierQueue.sync(flags: .barrier) {
        downloader.fetchLoads.removeValue(forKey: url)
        if downloader.fetchLoads.isEmpty {
            downloadHolder = nil
        }
    }
}

let barrierQueue: DispatchQueue
let processQueue: DispatchQueue
let cancelQueue: DispatchQueue

barrierQueue.sync(flags: .barrier) { ... }

cancelQueue.async {
    _ = fetchLoad.cancelSemaphore?.wait(timeout: .distantFuture)
    fetchLoad.cancelSemaphore = nil
    prepareFetchLoad()
}

private func callCompletionHandlerFailure(error: Error, url: URL) {
    guard let downloader = downloadHolder, let fetchLoad = downloader.fetchLoad(for: url) else {
        return
    }
        
    // We need to clean the fetch load first, before actually calling completion handler.
    cleanFetchLoad(for: url)
        
    var leftSignal: Int
    repeat {
        leftSignal = fetchLoad.cancelSemaphore?.signal() ?? 0
    } while leftSignal != 0
        
    for content in fetchLoad.contents {
        content.options.callbackDispatchQueue.safeAsync {
            content.callback.completionHandler?(nil, error as NSError, url, nil)
        }
    }
}

private func processImage(for task: URLSessionTask, url: URL) {...}

if let data = data, image == nil {
    image = processor.process(item: .data(data), options: options)
    // Add the processed image to cache. 
    // If `image` is nil, nothing will happen (since the key is not existing before).
    imageCache[processor.identifier] = image
}

if let image = image {
    downloader.delegate?.imageDownloader(downloader, didDownload: image, for: url, with: task.response)

    let imageModifier = options.imageModifier
    let finalImage = imageModifier.modify(image)

    if options.backgroundDecode {
        let decodedImage = finalImage.kf.decoded
        callbackQueue.safeAsync { completionHandler?(decodedImage, nil, url, data) }
    } else {
        callbackQueue.safeAsync { completionHandler?(finalImage, nil, url, data) }
    }       
}