| /* | |
| * This file is part of the SDWebImage package. | |
| * (c) Olivier Poitrey <rs@dailymotion.com> | |
| * | |
| * For the full copyright and license information, please view the LICENSE | |
| * file that was distributed with this source code. | |
| */ | |
| #import "SDWebImageManager.h" | |
| #import <objc/message.h> | |
| @interface SDWebImageCombinedOperation : NSObject <SDWebImageOperation> | |
| @property (assign, nonatomic, getter = isCancelled) BOOL cancelled; | |
| @property (copy, nonatomic) SDWebImageNoParamsBlock cancelBlock; | |
| @property (strong, nonatomic) NSOperation *cacheOperation; | |
| @end | |
| @interface SDWebImageManager () | |
| @property (strong, nonatomic, readwrite) SDImageCache *imageCache; | |
| @property (strong, nonatomic, readwrite) SDWebImageDownloader *imageDownloader; | |
| @property (strong, nonatomic) NSMutableArray *failedURLs; | |
| @property (strong, nonatomic) NSMutableArray *runningOperations; | |
| @end | |
| @implementation SDWebImageManager | |
| + (id)sharedManager { | |
| static dispatch_once_t once; | |
| static id instance; | |
| dispatch_once(&once, ^{ | |
| instance = [self new]; | |
| }); | |
| return instance; | |
| } | |
| - (id)init { | |
| if ((self = [super init])) { | |
| _imageCache = [self createCache]; | |
| _imageDownloader = [SDWebImageDownloader sharedDownloader]; | |
| _failedURLs = [NSMutableArray new]; | |
| _runningOperations = [NSMutableArray new]; | |
| } | |
| return self; | |
| } | |
| - (SDImageCache *)createCache { | |
| return [SDImageCache sharedImageCache]; | |
| } | |
| - (NSString *)cacheKeyForURL:(NSURL *)url { | |
| if (self.cacheKeyFilter) { | |
| return self.cacheKeyFilter(url); | |
| } | |
| else { | |
| return [url absoluteString]; | |
| } | |
| } | |
| - (BOOL)cachedImageExistsForURL:(NSURL *)url { | |
| NSString *key = [self cacheKeyForURL:url]; | |
| if ([self.imageCache imageFromMemoryCacheForKey:key] != nil) return YES; | |
| return [self.imageCache diskImageExistsWithKey:key]; | |
| } | |
| - (BOOL)diskImageExistsForURL:(NSURL *)url { | |
| NSString *key = [self cacheKeyForURL:url]; | |
| return [self.imageCache diskImageExistsWithKey:key]; | |
| } | |
| - (void)cachedImageExistsForURL:(NSURL *)url | |
| completion:(SDWebImageCheckCacheCompletionBlock)completionBlock { | |
| NSString *key = [self cacheKeyForURL:url]; | |
| BOOL isInMemoryCache = ([self.imageCache imageFromMemoryCacheForKey:key] != nil); | |
| if (isInMemoryCache) { | |
| // making sure we call the completion block on the main queue | |
| dispatch_async(dispatch_get_main_queue(), ^{ | |
| if (completionBlock) { | |
| completionBlock(YES); | |
| } | |
| }); | |
| return; | |
| } | |
| [self.imageCache diskImageExistsWithKey:key completion:^(BOOL isInDiskCache) { | |
| // the completion block of checkDiskCacheForImageWithKey:completion: is always called on the main queue, no need to further dispatch | |
| if (completionBlock) { | |
| completionBlock(isInDiskCache); | |
| } | |
| }]; | |
| } | |
| - (void)diskImageExistsForURL:(NSURL *)url | |
| completion:(SDWebImageCheckCacheCompletionBlock)completionBlock { | |
| NSString *key = [self cacheKeyForURL:url]; | |
| [self.imageCache diskImageExistsWithKey:key completion:^(BOOL isInDiskCache) { | |
| // the completion block of checkDiskCacheForImageWithKey:completion: is always called on the main queue, no need to further dispatch | |
| if (completionBlock) { | |
| completionBlock(isInDiskCache); | |
| } | |
| }]; | |
| } | |
| - (id <SDWebImageOperation>)downloadImageWithURL:(NSURL *)url | |
| options:(SDWebImageOptions)options | |
| progress:(SDWebImageDownloaderProgressBlock)progressBlock | |
| completed:(SDWebImageCompletionWithFinishedBlock)completedBlock { | |
| // Invoking this method without a completedBlock is pointless | |
| NSParameterAssert(completedBlock); | |
| // Very common mistake is to send the URL using NSString object instead of NSURL. For some strange reason, XCode won't | |
| // throw any warning for this type mismatch. Here we failsafe this error by allowing URLs to be passed as NSString. | |
| if ([url isKindOfClass:NSString.class]) { | |
| url = [NSURL URLWithString:(NSString *)url]; | |
| } | |
| // Prevents app crashing on argument type error like sending NSNull instead of NSURL | |
| if (![url isKindOfClass:NSURL.class]) { | |
| url = nil; | |
| } | |
| __block SDWebImageCombinedOperation *operation = [SDWebImageCombinedOperation new]; | |
| __weak SDWebImageCombinedOperation *weakOperation = operation; | |
| BOOL isFailedUrl = NO; | |
| @synchronized (self.failedURLs) { | |
| isFailedUrl = [self.failedURLs containsObject:url]; | |
| } | |
| if (!url || (!(options & SDWebImageRetryFailed) && isFailedUrl)) { | |
| dispatch_main_sync_safe(^{ | |
| NSError *error = [NSError errorWithDomain:NSURLErrorDomain code:NSURLErrorFileDoesNotExist userInfo:nil]; | |
| completedBlock(nil, error, SDImageCacheTypeNone, YES, url); | |
| }); | |
| return operation; | |
| } | |
| @synchronized (self.runningOperations) { | |
| [self.runningOperations addObject:operation]; | |
| } | |
| NSString *key = [self cacheKeyForURL:url]; | |
| operation.cacheOperation = [self.imageCache queryDiskCacheForKey:key done:^(UIImage *image, SDImageCacheType cacheType) { | |
| if (operation.isCancelled) { | |
| @synchronized (self.runningOperations) { | |
| [self.runningOperations removeObject:operation]; | |
| } | |
| return; | |
| } | |
| if ((!image || options & SDWebImageRefreshCached) && (![self.delegate respondsToSelector:@selector(imageManager:shouldDownloadImageForURL:)] || [self.delegate imageManager:self shouldDownloadImageForURL:url])) { | |
| if (image && options & SDWebImageRefreshCached) { | |
| dispatch_main_sync_safe(^{ | |
| // If image was found in the cache bug SDWebImageRefreshCached is provided, notify about the cached image | |
| // AND try to re-download it in order to let a chance to NSURLCache to refresh it from server. | |
| completedBlock(image, nil, cacheType, YES, url); | |
| }); | |
| } | |
| // download if no image or requested to refresh anyway, and download allowed by delegate | |
| 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 (image && 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; | |
| } | |
| id <SDWebImageOperation> subOperation = [self.imageDownloader downloadImageWithURL:url options:downloaderOptions progress:progressBlock completed:^(UIImage *downloadedImage, NSData *data, NSError *error, BOOL finished) { | |
| if (weakOperation.isCancelled) { | |
| // Do nothing if the operation was cancelled | |
| // See #699 for more details | |
| // if we would call the completedBlock, there could be a race condition between this block and another completedBlock for the same object, so if this one is called second, we will overwrite the new data | |
| } | |
| else if (error) { | |
| dispatch_main_sync_safe(^{ | |
| if (!weakOperation.isCancelled) { | |
| completedBlock(nil, error, SDImageCacheTypeNone, finished, url); | |
| } | |
| }); | |
| if (error.code != NSURLErrorNotConnectedToInternet && error.code != NSURLErrorCancelled && error.code != NSURLErrorTimedOut) { | |
| @synchronized (self.failedURLs) { | |
| [self.failedURLs addObject:url]; | |
| } | |
| } | |
| } | |
| else { | |
| BOOL cacheOnDisk = !(options & SDWebImageCacheMemoryOnly); | |
| if (options & SDWebImageRefreshCached && image && !downloadedImage) { | |
| // Image refresh hit the NSURLCache cache, do not call the completion block | |
| } | |
| // NOTE: We don't call transformDownloadedImage delegate method on animated images as most transformation code would mangle it | |
| else if (downloadedImage && !downloadedImage.images && [self.delegate respondsToSelector:@selector(imageManager:transformDownloadedImage:withURL:)]) { | |
| dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0), ^{ | |
| UIImage *transformedImage = [self.delegate imageManager:self transformDownloadedImage:downloadedImage withURL:url]; | |
| if (transformedImage && finished) { | |
| BOOL imageWasTransformed = ![transformedImage isEqual:downloadedImage]; | |
| [self.imageCache storeImage:transformedImage recalculateFromImage:imageWasTransformed imageData:data forKey:key toDisk:cacheOnDisk]; | |
| } | |
| dispatch_main_sync_safe(^{ | |
| if (!weakOperation.isCancelled) { | |
| completedBlock(transformedImage, nil, SDImageCacheTypeNone, finished, url); | |
| } | |
| }); | |
| }); | |
| } | |
| else { | |
| if (downloadedImage && finished) { | |
| [self.imageCache storeImage:downloadedImage recalculateFromImage:NO imageData:data forKey:key toDisk:cacheOnDisk]; | |
| } | |
| dispatch_main_sync_safe(^{ | |
| if (!weakOperation.isCancelled) { | |
| completedBlock(downloadedImage, nil, SDImageCacheTypeNone, finished, url); | |
| } | |
| }); | |
| } | |
| } | |
| if (finished) { | |
| @synchronized (self.runningOperations) { | |
| [self.runningOperations removeObject:operation]; | |
| } | |
| } | |
| }]; | |
| operation.cancelBlock = ^{ | |
| [subOperation cancel]; | |
| @synchronized (self.runningOperations) { | |
| [self.runningOperations removeObject:weakOperation]; | |
| } | |
| }; | |
| } | |
| else if (image) { | |
| dispatch_main_sync_safe(^{ | |
| if (!weakOperation.isCancelled) { | |
| completedBlock(image, nil, cacheType, YES, url); | |
| } | |
| }); | |
| @synchronized (self.runningOperations) { | |
| [self.runningOperations removeObject:operation]; | |
| } | |
| } | |
| else { | |
| // Image not in cache and download disallowed by delegate | |
| dispatch_main_sync_safe(^{ | |
| if (!weakOperation.isCancelled) { | |
| completedBlock(nil, nil, SDImageCacheTypeNone, YES, url); | |
| } | |
| }); | |
| @synchronized (self.runningOperations) { | |
| [self.runningOperations removeObject:operation]; | |
| } | |
| } | |
| }]; | |
| return operation; | |
| } | |
| - (void)saveImageToCache:(UIImage *)image forURL:(NSURL *)url { | |
| if (image && url) { | |
| NSString *key = [self cacheKeyForURL:url]; | |
| [self.imageCache storeImage:image forKey:key toDisk:YES]; | |
| } | |
| } | |
| - (void)cancelAll { | |
| @synchronized (self.runningOperations) { | |
| [self.runningOperations makeObjectsPerformSelector:@selector(cancel)]; | |
| [self.runningOperations removeAllObjects]; | |
| } | |
| } | |
| - (BOOL)isRunning { | |
| return self.runningOperations.count > 0; | |
| } | |
| @end | |
| @implementation SDWebImageCombinedOperation | |
| - (void)setCancelBlock:(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]; | |
| } | |
| } | |
| - (void)cancel { | |
| self.cancelled = YES; | |
| if (self.cacheOperation) { | |
| [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 | |
| @implementation SDWebImageManager (Deprecated) | |
| // deprecated method, uses the non deprecated method | |
| // adapter for the completion block | |
| - (id <SDWebImageOperation>)downloadWithURL:(NSURL *)url options:(SDWebImageOptions)options progress:(SDWebImageDownloaderProgressBlock)progressBlock completed:(SDWebImageCompletedWithFinishedBlock)completedBlock { | |
| return [self downloadImageWithURL:url | |
| options:options | |
| progress:progressBlock | |
| completed:^(UIImage *image, NSError *error, SDImageCacheType cacheType, BOOL finished, NSURL *imageURL) { | |
| if (completedBlock) { | |
| completedBlock(image, error, cacheType, finished); | |
| } | |
| }]; | |
| } | |
| @end |