| /* |
| * 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) NSMutableSet *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 = [NSMutableSet 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 |
| NSAssert(completedBlock != nil, @"If you mean to prefetch the image, use -[SDWebImagePrefetcher prefetchURLs] instead"); |
| |
| // 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.absoluteString.length == 0 || (!(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 but 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) { |
| __strong __typeof(weakOperation) strongOperation = weakOperation; |
| if (!strongOperation || strongOperation.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 (strongOperation && !strongOperation.isCancelled) { |
| completedBlock(nil, error, SDImageCacheTypeNone, finished, url); |
| } |
| }); |
| |
| if ( error.code != NSURLErrorNotConnectedToInternet |
| && error.code != NSURLErrorCancelled |
| && error.code != NSURLErrorTimedOut |
| && error.code != NSURLErrorInternationalRoamingOff |
| && error.code != NSURLErrorDataNotAllowed |
| && error.code != NSURLErrorCannotFindHost |
| && error.code != NSURLErrorCannotConnectToHost) { |
| @synchronized (self.failedURLs) { |
| [self.failedURLs addObject:url]; |
| } |
| } |
| } |
| else { |
| if ((options & SDWebImageRetryFailed)) { |
| @synchronized (self.failedURLs) { |
| [self.failedURLs removeObject:url]; |
| } |
| } |
| |
| BOOL cacheOnDisk = !(options & SDWebImageCacheMemoryOnly); |
| |
| if (options & SDWebImageRefreshCached && image && !downloadedImage) { |
| // Image refresh hit the NSURLCache cache, do not call the completion block |
| } |
| else if (downloadedImage && (!downloadedImage.images || (options & SDWebImageTransformAnimatedImage)) && [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:(imageWasTransformed ? nil : data) forKey:key toDisk:cacheOnDisk]; |
| } |
| |
| dispatch_main_sync_safe(^{ |
| if (strongOperation && !strongOperation.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 (strongOperation && !strongOperation.isCancelled) { |
| completedBlock(downloadedImage, nil, SDImageCacheTypeNone, finished, url); |
| } |
| }); |
| } |
| } |
| |
| if (finished) { |
| @synchronized (self.runningOperations) { |
| if (strongOperation) { |
| [self.runningOperations removeObject:strongOperation]; |
| } |
| } |
| } |
| }]; |
| operation.cancelBlock = ^{ |
| [subOperation cancel]; |
| |
| @synchronized (self.runningOperations) { |
| __strong __typeof(weakOperation) strongOperation = weakOperation; |
| if (strongOperation) { |
| [self.runningOperations removeObject:strongOperation]; |
| } |
| } |
| }; |
| } |
| else if (image) { |
| dispatch_main_sync_safe(^{ |
| __strong __typeof(weakOperation) strongOperation = weakOperation; |
| if (strongOperation && !strongOperation.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(^{ |
| __strong __typeof(weakOperation) strongOperation = weakOperation; |
| if (strongOperation && !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) { |
| NSArray *copiedOperations = [self.runningOperations copy]; |
| [copiedOperations makeObjectsPerformSelector:@selector(cancel)]; |
| [self.runningOperations removeObjectsInArray:copiedOperations]; |
| } |
| } |
| |
| - (BOOL)isRunning { |
| BOOL isRunning = NO; |
| @synchronized(self.runningOperations) { |
| isRunning = (self.runningOperations.count > 0); |
| } |
| return isRunning; |
| } |
| |
| @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 |
