SDWebImage源码解析

@param url 图片的url地址
 @param options 获取图片的属性
 @param progressBlock 加载进度回调
 @param completedBlock 加载完成回调
 @return 返回一个加载的载体对象。以便提供给后面取消删除等。
 */
- (id <SDWebImageOperation>)loadImageWithURL:(nullable NSURL *)url
                                     options:(SDWebImageOptions)options
                                    progress:(nullable SDWebImageDownloaderProgressBlock)progressBlock
                                   completed:(nullable SDInternalCompletionBlock)completedBlock {
    /*
     如果传入的url是NSString格式的。则转换为NSURL类型再处理
     */
    if ([url isKindOfClass:NSString.class]) {
        url = [NSURL URLWithString:(NSString *)url];
    }
    //Prevents app crashing on argument type error like sending NSNull instead of NSURL
    //如果url不会NSURL类型的对象。则置为nil
    if (![url isKindOfClass:NSURL.class]) {
        url =nil;
    }
    /*
     图片加载获取获取过程中绑定一个`SDWebImageCombinedOperation`对象。以方便后续再通过这个对象对url的加载控制。
     */
    __block SDWebImageCombinedOperation *operation = [SDWebImageCombinedOperation new];
    __weak SDWebImageCombinedOperation *weakOperation =operation;
    BOOL isFailedUrl =NO;
    //当前url是否在失败url的集合里面
    if(url) {
        @synchronized (self.failedURLs) {
            isFailedUrl =[self.failedURLs containsObject:url];
        }
    }
    /*
     如果url是失败的url或者url有问题等各种问题。则直接根据opeation来做异常情况的处理
     */
    if (url.absoluteString.length == 0 || (!(options & SDWebImageRetryFailed) &&isFailedUrl)) {
        //构建回调Block
[self callCompletionBlockForOperation:operation completion:completedBlock error:[NSError errorWithDomain:NSURLErrorDomain code:NSURLErrorFileDoesNotExist userInfo:nil] url:url];
        returnoperation;
    }
    //把加载图片的一个载体存入runningOperations。里面是所有正在做图片加载过程的operation的集合。
@synchronized (self.runningOperations) {
        [self.runningOperations addObject:operation];
    }
    //根据url获取url对应的key
    NSString *key =[self cacheKeyForURL:url];
    /*
    *如果图片是从内存加载，则返回的cacheOperation是nil，
    *如果是从磁盘加载，则返回的cacheOperation是`NSOperation`对象。
    *如果是从网络加载，则返回的cacheOperation对象是`SDWebImageDownloaderOperation`对象。
    */
    operation.cacheOperation = [self.imageCache queryCacheOperationForKey:key done:^(UIImage *cachedImage, NSData *cachedData, SDImageCacheType cacheType) {
        //从缓存中获取图片数据返回
        //如果已经取消了操作。则直接返回并且移除对应的opetation对象
        if(operation.isCancelled) {
            [self safelyRemoveOperationFromRunning:operation];
            return;
        }
        if ((!cachedImage || options & SDWebImageRefreshCached) && (![self.delegate respondsToSelector:@selector(imageManager:shouldDownloadImageForURL:)] || [self.delegateimageManager:self shouldDownloadImageForURL:url])) {
            /**
             如果从缓存获取图片失败。或者设置了SDWebImageRefreshCached来忽略缓存。则先把缓存的图片返回。
             */
            if (cachedImage && options &SDWebImageRefreshCached) {
                //构建回调Block
[self callCompletionBlockForOperation:weakOperation completion:completedBlock image:cachedImage data:cachedData error:nil cacheType:cacheType finished:YES url:url];
            }
            //download if no image or requested to refresh anyway, and download allowed by delegate
            /*
             把图片加载的`SDWebImageOptions`类型枚举转换为图片下载的`SDWebImageDownloaderOptions`类型的枚举
             */
            SDWebImageDownloaderOptions downloaderOptions = 0;
            if (options & SDWebImageLowPriority) downloaderOptions |=SDWebImageDownloaderLowPriority;
            if (options & SDWebImageProgressiveDownload) downloaderOptions |=SDWebImageDownloaderProgressiveDownload;
            if (options & SDWebImageRefreshCached) downloaderOptions |=SDWebImageDownloaderUseNSURLCache;
            if (options & SDWebImageContinueInBackground) downloaderOptions |=SDWebImageDownloaderContinueInBackground;
            if (options & SDWebImageHandleCookies) downloaderOptions |=SDWebImageDownloaderHandleCookies;
            if (options & SDWebImageAllowInvalidSSLCertificates) downloaderOptions |=SDWebImageDownloaderAllowInvalidSSLCertificates;
            if (options & SDWebImageHighPriority) downloaderOptions |=SDWebImageDownloaderHighPriority;
            if (options & SDWebImageScaleDownLargeImages) downloaderOptions |=SDWebImageDownloaderScaleDownLargeImages;
            /*
             如果设置了强制刷新缓存的选项。则`SDWebImageDownloaderProgressiveDownload`选项失效并且添加`SDWebImageDownloaderIgnoreCachedResponse`选项。
             */
            if (cachedImage && options &SDWebImageRefreshCached) {
                //force progressive off if image already cached but forced refreshing
                downloaderOptions &= ~SDWebImageDownloaderProgressiveDownload;
                //ignore image read from NSURLCache if image if cached but force refreshing
                downloaderOptions |=SDWebImageDownloaderIgnoreCachedResponse;
            }
            /*
             新建一个网络下载的操作。
             */
            SDWebImageDownloadToken *subOperationToken = [self.imageDownloader downloadImageWithURL:url options:downloaderOptions progress:progressBlock completed:^(UIImage *downloadedImage, NSData *downloadedData, NSError *error, BOOL finished) {
                __strong __typeof(weakOperation) strongOperation =weakOperation;
                //如果图片下载结束以后，对应的图片加载操作已经取消。则什么处理都不做
                if (!strongOperation ||strongOperation.isCancelled) {
                   //如果operation已经被取消了，则什么也不做
                } else if(error) {
                    //如果加载出错。则直接返回回调。并且添加到failedURLs中
[self callCompletionBlockForOperation:strongOperation completion:completedBlock error:error url:url];
                    if (   error.code !=NSURLErrorNotConnectedToInternet
                        && error.code !=NSURLErrorCancelled
                        && error.code !=NSURLErrorTimedOut
                        && error.code !=NSURLErrorInternationalRoamingOff
                        && error.code !=NSURLErrorDataNotAllowed
                        && error.code !=NSURLErrorCannotFindHost
                        && error.code !=NSURLErrorCannotConnectToHost
                        && error.code !=NSURLErrorNetworkConnectionLost) {
                        @synchronized (self.failedURLs) {
                            [self.failedURLs addObject:url];
                        }
                    }
                }
                else{
                    //网络图片加载成功
                    if ((options &SDWebImageRetryFailed)) {
                        //如果有重试失败下载的选项。则把url从failedURLS中移除
@synchronized (self.failedURLs) {
                            [self.failedURLs removeObject:url];
                        }
                    }
                    BOOL cacheOnDisk = !(options &SDWebImageCacheMemoryOnly);
                    if (options & SDWebImageRefreshCached && cachedImage && !downloadedImage) {
                        //Image refresh hit the NSURLCache cache, do not call the completion block
                        //如果成功下载图片。并且图片是动态图片。并且设置了SDWebImageTransformAnimatedImage属性。则处理图片
                    } else if (downloadedImage && (!downloadedImage.images || (options & SDWebImageTransformAnimatedImage)) && [self.delegaterespondsToSelector:@selector(imageManager:transformDownloadedImage:withURL:)]) {
                        dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0), ^{
                            //获取transform以后的图片
                            UIImage *transformedImage = [self.delegateimageManager:self transformDownloadedImage:downloadedImage withURL:url];
                            //存储transform以后的的图片
                            if (transformedImage &&finished) {
                                BOOL imageWasTransformed = ![transformedImage isEqual:downloadedImage];
                                //pass nil if the image was transformed, so we can recalculate the data from the image
                                [self.imageCache storeImage:transformedImage imageData:(imageWasTransformed ?nil : downloadedData) forKey:key toDisk:cacheOnDisk completion:nil];
                            }
                            //回调拼接
[self callCompletionBlockForOperation:strongOperation completion:completedBlock image:transformedImage data:downloadedData error:nil cacheType:SDImageCacheTypeNone finished:finished url:url];
                        });
                    } else{
                        //如果成功下载图片。并且图片不是图片。则直接缓存和回调
                        if (downloadedImage &&finished) {
                            [self.imageCache storeImage:downloadedImage imageData:downloadedData forKey:key toDisk:cacheOnDisk completion:nil];
                        }
                        //回调拼接
[self callCompletionBlockForOperation:strongOperation completion:completedBlock image:downloadedImage data:downloadedData error:nil cacheType:SDImageCacheTypeNone finished:finished url:url];
                    }
                }
                //从正在加载的图片操作集合中移除当前操作
                if(finished) {
                    [self safelyRemoveOperationFromRunning:strongOperation];
                }
            }];
            //重置cancelBlock，取消下载operation
            operation.cancelBlock = ^{
                [self.imageDownloader cancel:subOperationToken];
                __strong __typeof(weakOperation) strongOperation =weakOperation;
                [self safelyRemoveOperationFromRunning:strongOperation];
            };
        } else if(cachedImage) {
            //如果获取到了缓存图片。在直接通过缓存图片处理
            __strong __typeof(weakOperation) strongOperation =weakOperation;
            [self callCompletionBlockForOperation:strongOperation completion:completedBlock image:cachedImage data:cachedData error:nil cacheType:cacheType finished:YES url:url];
            [self safelyRemoveOperationFromRunning:operation];
        } else{
            //Image not in cache and download disallowed by delegate
            //图片么有缓存、并且图片也没有下载
            __strong __typeof(weakOperation) strongOperation =weakOperation;
            [self callCompletionBlockForOperation:strongOperation completion:completedBlock image:nil data:nil error:nil cacheType:SDImageCacheTypeNone finished:YES url:url];
            [self safelyRemoveOperationFromRunning:operation];
        }
    }];
    returnoperation;
}

/**
 通过这个对象关联一个`SDWebImageDownloaderOperation`对象
 */
@interface SDWebImageCombinedOperation : NSObject <SDWebImageOperation>
/**
 用于判断Operation是否已经取消
 */
@property (assign, nonatomic, getter =isCancelled) BOOL cancelled;
/**
 取消回调
 */
@property (copy, nonatomic, nullable) SDWebImageNoParamsBlock cancelBlock;
/**
 SDWebImageDownloaderOperation对象。可以通过这个属性取消一个NSOperation
 */
@property (strong, nonatomic, nullable) NSOperation *cacheOperation;
@end
@implementationSDWebImageCombinedOperation
/**
 取消Operation的回调Block
 @param cancelBlock 回调Block
 */
- (void)setCancelBlock:(nullable SDWebImageNoParamsBlock)cancelBlock {
    //check if the operation is already cancelled, then we just call the cancelBlock
    if(self.isCancelled) {
        if(cancelBlock) {
            cancelBlock();
        }
        _cancelBlock = nil; //don't forget to nil the cancelBlock, otherwise we will get crashes
    } else{
        _cancelBlock =[cancelBlock copy];
    }
}
/**
 调用cancel方法。这个方法继承自`SDWebImageOperation`协议。方法里面会调用`SDWebImageDownlaoderOperation`或者`NSOperation`的cancel方法
 */
- (void)cancel {
    self.cancelled =YES;
    if(self.cacheOperation) {
        //调用`SDWebImageDownlaoderOperation`或者`NSOperation`的cancel方法
[self.cacheOperation cancel];
        self.cacheOperation =nil;
    }
    if(self.cancelBlock) {
        self.cancelBlock();
        //TODO: this is a temporary fix to #809.
        //Until we can figure the exact cause of the crash, going with the ivar instead of the setter
        //self.cancelBlock = nil;
        _cancelBlock =nil;
    }
}
@end

//创建单例模式
+(nonnull instancetype)sharedImageCache {
    staticdispatch_once_t once;
    static idinstance;
    dispatch_once(&once, ^{
        instance = [self new];
    });
    returninstance;
}
//
- (nonnull instancetype)initWithNamespace:(nonnull NSString *)ns {
    NSString *path =[self makeDiskCachePath:ns];
    return[self initWithNamespace:ns diskCacheDirectory:path];
}
- (nonnull instancetype)initWithNamespace:(nonnull NSString *)ns
                       diskCacheDirectory:(nonnull NSString *)directory {
    if ((self =[super init])) {
        NSString *fullNamespace = [@"com.hackemist.SDWebImageCache."stringByAppendingString:ns];
        //Create IO serial queue
        _ioQueue = dispatch_queue_create("com.hackemist.SDWebImageCache", DISPATCH_QUEUE_SERIAL);
        _config =[[SDImageCacheConfig alloc] init];
        //Init the memory cache
        _memCache =[[AutoPurgeCache alloc] init];
        _memCache.name =fullNamespace;
        //Init the disk cache
        if (directory !=nil) {
            _diskCachePath =[directory stringByAppendingPathComponent:fullNamespace];
        } else{
            NSString *path =[self makeDiskCachePath:ns];
            _diskCachePath =path;
        }
        dispatch_sync(_ioQueue, ^{
            _fileManager = [NSFileManager new];
        });
#if SD_UIKIT
        //Subscribe to app events
[[NSNotificationCenter defaultCenter] addObserver:self
                                                 selector:@selector(clearMemory)
                                                     name:UIApplicationDidReceiveMemoryWarningNotification
                                                   object:nil];
        [[NSNotificationCenter defaultCenter] addObserver:self
                                                 selector:@selector(deleteOldFiles)
                                                     name:UIApplicationWillTerminateNotification
                                                   object:nil];
        [[NSNotificationCenter defaultCenter] addObserver:self
                                                 selector:@selector(backgroundDeleteOldFiles)
                                                     name:UIApplicationDidEnterBackgroundNotification
                                                   object:nil];
#endif
    }
    returnself;
}

- (void)storeImage:(nullable UIImage *)image
            forKey:(nullable NSString *)key
        completion:(nullable SDWebImageNoParamsBlock)completionBlock {
    [self storeImage:image imageData:nil forKey:key toDisk:YES completion:completionBlock];
}
- (void)storeImage:(nullable UIImage *)image
            forKey:(nullable NSString *)key
            toDisk:(BOOL)toDisk
        completion:(nullable SDWebImageNoParamsBlock)completionBlock {
    [self storeImage:image imageData:nil forKey:key toDisk:toDisk completion:completionBlock];
}
- (void)storeImage:(nullable UIImage *)image
         imageData:(nullable NSData *)imageData
            forKey:(nullable NSString *)key
            toDisk:(BOOL)toDisk
        completion:(nullable SDWebImageNoParamsBlock)completionBlock {
    if (!image || !key) {
        if(completionBlock) {
            completionBlock();
        }
        return;
    }
    //if memory cache is enabled
    if(self.config.shouldCacheImagesInMemory) {
        NSUInteger cost =SDCacheCostForImage(image);
        [self.memCache setObject:image forKey:key cost:cost];
    }
    if(toDisk) {
        dispatch_async(self.ioQueue, ^{
            @autoreleasepool {
                NSData *data =imageData;
                if (!data &&image) {
                    //If we do not have any data to detect image format, check whether it contains alpha channel to use PNG or JPEG format
SDImageFormat format;
                    if(SDCGImageRefContainsAlpha(image.CGImage)) {
                        format =SDImageFormatPNG;
                    } else{
                        format =SDImageFormatJPEG;
                    }
                    data =[[SDWebImageCodersManager sharedInstance] encodedDataWithImage:image format:format];
                }
                [self storeImageDataToDisk:data forKey:key];
            }
            if(completionBlock) {
                dispatch_async(dispatch_get_main_queue(), ^{
                    completionBlock();
                });
            }
        });
    } else{
        if(completionBlock) {
            completionBlock();
        }
    }
}
- (void)storeImageDataToDisk:(nullable NSData *)imageData forKey:(nullable NSString *)key {
    if (!imageData || !key) {
        return;
    }
    [self checkIfQueueIsIOQueue];
    if (![_fileManager fileExistsAtPath:_diskCachePath]) {
        [_fileManager createDirectoryAtPath:_diskCachePath withIntermediateDirectories:YES attributes:nil error:NULL];
    }
    //get cache Path for image key
    NSString *cachePathForKey =[self defaultCachePathForKey:key];
    //transform to NSUrl
    NSURL *fileURL =[NSURL fileURLWithPath:cachePathForKey];
    [_fileManager createFileAtPath:cachePathForKey contents:imageData attributes:nil];
    //disable iCloud backup
    if(self.config.shouldDisableiCloud) {
        [fileURL setResourceValue:@YES forKey:NSURLIsExcludedFromBackupKey error:nil];
    }
}

- (void)diskImageExistsWithKey:(nullable NSString *)key completion:(nullable SDWebImageCheckCacheCompletionBlock)completionBlock {
    dispatch_async(_ioQueue, ^{
        BOOL exists =[_fileManager fileExistsAtPath:[self defaultCachePathForKey:key]];
        //fallback because of https://github.com/rs/SDWebImage/pull/976that added the extension to the disk file name
        //checking the key with and without the extension
        if (!exists) {
            exists =[_fileManager fileExistsAtPath:[self defaultCachePathForKey:key].stringByDeletingPathExtension];
        }
        if(completionBlock) {
            dispatch_async(dispatch_get_main_queue(), ^{
                completionBlock(exists);
            });
        }
    });
}
- (nullable UIImage *)imageFromMemoryCacheForKey:(nullable NSString *)key {
    return[self.memCache objectForKey:key];
}
- (nullable UIImage *)imageFromDiskCacheForKey:(nullable NSString *)key {
    UIImage *diskImage =[self diskImageForKey:key];
    if (diskImage &&self.config.shouldCacheImagesInMemory) {
        NSUInteger cost =SDCacheCostForImage(diskImage);
        [self.memCache setObject:diskImage forKey:key cost:cost];
    }
    returndiskImage;
}
- (nullable UIImage *)imageFromCacheForKey:(nullable NSString *)key {
    //First check the in-memory cache...
    UIImage *image =[self imageFromMemoryCacheForKey:key];
    if(image) {
        returnimage;
    }
    //Second check the disk cache...
    image =[self imageFromDiskCacheForKey:key];
    returnimage;
}
- (nullable NSData *)diskImageDataBySearchingAllPathsForKey:(nullable NSString *)key {
    NSString *defaultPath =[self defaultCachePathForKey:key];
    NSData *data =[NSData dataWithContentsOfFile:defaultPath options:self.config.diskCacheReadingOptions error:nil];
    if(data) {
        returndata;
    }
    //fallback because of https://github.com/rs/SDWebImage/pull/976that added the extension to the disk file name
    //checking the key with and without the extension
    data =[NSData dataWithContentsOfFile:defaultPath.stringByDeletingPathExtension options:self.config.diskCacheReadingOptions error:nil];
    if(data) {
        returndata;
    }
    NSArray<NSString *> *customPaths =[self.customPaths copy];
    for (NSString *path incustomPaths) {
        NSString *filePath =[self cachePathForKey:key inPath:path];
        NSData *imageData =[NSData dataWithContentsOfFile:filePath options:self.config.diskCacheReadingOptions error:nil];
        if(imageData) {
            returnimageData;
        }
        //fallback because of https://github.com/rs/SDWebImage/pull/976that added the extension to the disk file name
        //checking the key with and without the extension
        imageData =[NSData dataWithContentsOfFile:filePath.stringByDeletingPathExtension options:self.config.diskCacheReadingOptions error:nil];
        if(imageData) {
            returnimageData;
        }
    }
    returnnil;
}
- (nullable UIImage *)diskImageForKey:(nullable NSString *)key {
    NSData *data =[self diskImageDataBySearchingAllPathsForKey:key];
    if(data) {
        UIImage *image =[[SDWebImageCodersManager sharedInstance] decodedImageWithData:data];
        image =[self scaledImageForKey:key image:image];
        if(self.config.shouldDecompressImages) {
            image = [[SDWebImageCodersManager sharedInstance] decompressedImageWithImage:image data:&data options:@{SDWebImageCoderScaleDownLargeImagesKey: @(NO)}];
        }
        returnimage;
    } else{
        returnnil;
    }
}
- (nullable UIImage *)scaledImageForKey:(nullable NSString *)key image:(nullable UIImage *)image {
    returnSDScaledImageForKey(key, image);
}
- (nullable NSOperation *)queryCacheOperationForKey:(nullable NSString *)key done:(nullable SDCacheQueryCompletedBlock)doneBlock {
    if (!key) {
        if(doneBlock) {
            doneBlock(nil, nil, SDImageCacheTypeNone);
        }
        returnnil;
    }
    //First check the in-memory cache...
    UIImage *image =[self imageFromMemoryCacheForKey:key];
    if(image) {
        NSData *diskData =nil;
        if(image.images) {
            diskData =[self diskImageDataBySearchingAllPathsForKey:key];
        }
        if(doneBlock) {
            doneBlock(image, diskData, SDImageCacheTypeMemory);
        }
        returnnil;
    }
    NSOperation *operation = [NSOperation new];
    dispatch_async(self.ioQueue, ^{
        if(operation.isCancelled) {
            //do not call the completion if cancelled
            return;
        }
        @autoreleasepool {
            NSData *diskData =[self diskImageDataBySearchingAllPathsForKey:key];
            UIImage *diskImage =[self diskImageForKey:key];
            if (diskImage &&self.config.shouldCacheImagesInMemory) {
                NSUInteger cost =SDCacheCostForImage(diskImage);
                [self.memCache setObject:diskImage forKey:key cost:cost];
            }
            if(doneBlock) {
                dispatch_async(dispatch_get_main_queue(), ^{
                    doneBlock(diskImage, diskData, SDImageCacheTypeDisk);
                });
            }
        }
    });
    returnoperation;
}

- (void)clearMemory {
    [self.memCache removeAllObjects];
}
- (void)clearDiskOnCompletion:(nullable SDWebImageNoParamsBlock)completion {
    dispatch_async(self.ioQueue, ^{
        [_fileManager removeItemAtPath:self.diskCachePath error:nil];
        [_fileManager createDirectoryAtPath:self.diskCachePath
                withIntermediateDirectories:YES
                                 attributes:nil
                                      error:NULL];
        if(completion) {
            dispatch_async(dispatch_get_main_queue(), ^{
                completion();
            });
        }
    });
}
- (void)deleteOldFiles {
    [self deleteOldFilesWithCompletionBlock:nil];
}
- (void)deleteOldFilesWithCompletionBlock:(nullable SDWebImageNoParamsBlock)completionBlock {
    dispatch_async(self.ioQueue, ^{
        NSURL *diskCacheURL =[NSURL fileURLWithPath:self.diskCachePath isDirectory:YES];
        NSArray<NSString *> *resourceKeys =@[NSURLIsDirectoryKey, NSURLContentModificationDateKey, NSURLTotalFileAllocatedSizeKey];
        //This enumerator prefetches useful properties for our cache files.
        NSDirectoryEnumerator *fileEnumerator =[_fileManager enumeratorAtURL:diskCacheURL
                                                   includingPropertiesForKeys:resourceKeys
                                                                      options:NSDirectoryEnumerationSkipsHiddenFiles
                                                                 errorHandler:NULL];
        NSDate *expirationDate = [NSDate dateWithTimeIntervalSinceNow:-self.config.maxCacheAge];
        NSMutableDictionary<NSURL *, NSDictionary<NSString *, id> *> *cacheFiles =[NSMutableDictionary dictionary];
        NSUInteger currentCacheSize = 0;
        //Enumerate all of the files in the cache directory.  This loop has two purposes:
        //
        //1. Removing files that are older than the expiration date.
        //2. Storing file attributes for the size-based cleanup pass.
        NSMutableArray<NSURL *> *urlsToDelete =[[NSMutableArray alloc] init];
        for (NSURL *fileURL infileEnumerator) {
            NSError *error;
            NSDictionary<NSString *, id> *resourceValues = [fileURL resourceValuesForKeys:resourceKeys error:&error];
            //Skip directories and errors.
            if (error || !resourceValues ||[resourceValues[NSURLIsDirectoryKey] boolValue]) {
                continue;
            }
            //Remove files that are older than the expiration date;
            NSDate *modificationDate =resourceValues[NSURLContentModificationDateKey];
            if([[modificationDate laterDate:expirationDate] isEqualToDate:expirationDate]) {
                [urlsToDelete addObject:fileURL];
                continue;
            }
            //Store a reference to this file and account for its total size.
            NSNumber *totalAllocatedSize =resourceValues[NSURLTotalFileAllocatedSizeKey];
            currentCacheSize +=totalAllocatedSize.unsignedIntegerValue;
            cacheFiles[fileURL] =resourceValues;
        }
        for (NSURL *fileURL inurlsToDelete) {
            [_fileManager removeItemAtURL:fileURL error:nil];
        }
        //If our remaining disk cache exceeds a configured maximum size, perform a second
        //size-based cleanup pass.  We delete the oldest files first.
        if (self.config.maxCacheSize > 0 && currentCacheSize >self.config.maxCacheSize) {
            //Target half of our maximum cache size for this cleanup pass.
            const NSUInteger desiredCacheSize = self.config.maxCacheSize / 2;
            //Sort the remaining cache files by their last modification time (oldest first).
            NSArray<NSURL *> *sortedFiles =[cacheFiles keysSortedByValueWithOptions:NSSortConcurrent
                                                                     usingComparator:^NSComparisonResult(id obj1, idobj2) {
                                                                         return[obj1[NSURLContentModificationDateKey] compare:obj2[NSURLContentModificationDateKey]];
                                                                     }];
            //Delete files until we fall below our desired cache size.
            for (NSURL *fileURL insortedFiles) {
                if([_fileManager removeItemAtURL:fileURL error:nil]) {
                    NSDictionary<NSString *, id> *resourceValues =cacheFiles[fileURL];
                    NSNumber *totalAllocatedSize =resourceValues[NSURLTotalFileAllocatedSizeKey];
                    currentCacheSize -=totalAllocatedSize.unsignedIntegerValue;
                    if (currentCacheSize <desiredCacheSize) {
                        break;
                    }
                }
            }
        }
        if(completionBlock) {
            dispatch_async(dispatch_get_main_queue(), ^{
                completionBlock();
            });
        }
    });
}