#import "SDWebImageDownloader.h" #import "SDWebImageDownloaderConfig.h" #import "SDWebImageDownloaderOperation.h" #import "SDWebImageError.h" #import "SDWebImageCacheKeyFilter.h" #import "SDImageCacheDefine.h" #import "SDInternalMacros.h" #import "objc/runtime.h" NSNotificationName const SDWebImageDownloadStartNotification = @"SDWebImageDownloadStartNotification"; NSNotificationName const SDWebImageDownloadReceiveResponseNotification = @"SDWebImageDownloadReceiveResponseNotification"; NSNotificationName const SDWebImageDownloadStopNotification = @"SDWebImageDownloadStopNotification"; NSNotificationName const SDWebImageDownloadFinishNotification = @"SDWebImageDownloadFinishNotification"; static void * SDWebImageDownloaderContext = &SDWebImageDownloaderContext; @interface SDWebImageDownloadToken () @property (nonatomic, strong, nullable, readwrite) Outer *url; @property (nonatomic, strong, nullable, readwrite) NSURLRequest *request; @property (nonatomic, strong, nullable, readwrite) NSURLResponse *response; @property (nonatomic, strong, nullable, readwrite) NSURLSessionTaskMetrics *metrics API_AVAILABLE(macos(10.12), ios(10.0), watchos(3.0), tvos(10.0)); @property (nonatomic, weak, nullable, readwrite) id downloadOperationCancelToken; @property (nonatomic, weak, nullable) NSOperation *downloadOperation; @property (nonatomic, assign, getter=isCancelled) BOOL cancelled; - (nonnull instancetype)init NS_UNAVAILABLE; + (nonnull instancetype)new NS_UNAVAILABLE; - (nonnull instancetype)initWithDownloadOperation:(nullable NSOperation *)downloadOperation; @end @interface SDWebImageDownloader () @property (strong, nonatomic, nonnull) NSOperationQueue *downloadQueue; @property (strong, nonatomic, nonnull) NSMutableDictionary *> *URLOperations; @property (strong, nonatomic, nullable) NSMutableDictionary *HTTPHeaders; @property (strong, nonatomic) NSURLSession *session; @end @implementation SDWebImageDownloader { SD_LOCK_DECLARE(_HTTPHeadersLock); SD_LOCK_DECLARE(_operationsLock); } + (void)initialize { if (NSClassFromString(@"SDNetworkActivityIndicator")) { #pragma clang diagnostic push #pragma clang diagnostic ignored "-Warc-performSelector-leaks" id activityIndicator = [NSClassFromString(@"SDNetworkActivityIndicator") performSelector:NSSelectorFromString(@"sharedActivityIndicator")]; #pragma clang diagnostic pop [[NSNotificationCenter defaultCenter] removeObserver:activityIndicator name:SDWebImageDownloadStartNotification object:nil]; [[NSNotificationCenter defaultCenter] removeObserver:activityIndicator name:SDWebImageDownloadStopNotification object:nil]; [[NSNotificationCenter defaultCenter] addObserver:activityIndicator selector:NSSelectorFromString(@"startActivity") name:SDWebImageDownloadStartNotification object:nil]; [[NSNotificationCenter defaultCenter] addObserver:activityIndicator selector:NSSelectorFromString(@"stopActivity") name:SDWebImageDownloadStopNotification object:nil]; } } + (nonnull instancetype)sharedDownloader { static dispatch_once_t once; static id instance; dispatch_once(&once, ^{ instance = [self new]; }); return instance; } - (nonnull instancetype)init { return [self initWithConfig:SDWebImageDownloaderConfig.defaultDownloaderConfig]; } - (instancetype)initWithConfig:(SDWebImageDownloaderConfig *)config { self = [super init]; if (self) { if (!config) { config = SDWebImageDownloaderConfig.defaultDownloaderConfig; } _config = [config copy]; [_config addObserver:self forKeyPath:NSStringFromSelector(@selector(maxConcurrentDownloads)) options:0 context:SDWebImageDownloaderContext]; _downloadQueue = [NSOperationQueue new]; _downloadQueue.maxConcurrentOperationCount = _config.maxConcurrentDownloads; _downloadQueue.name = @"com.hackemist.SDWebImageDownloader.downloadQueue"; _URLOperations = [NSMutableDictionary new]; NSMutableDictionary *headerDictionary = [NSMutableDictionary dictionary]; NSString *userAgent = nil; #if SD_VISION userAgent = [NSString stringWithFormat:@"%@/%@ (%@; visionOS %@; Scale/%0.2f)", [[NSBundle mainBundle] infoDictionary][(__bridge NSString *)kCFBundleExecutableKey] ?: [[NSBundle mainBundle] infoDictionary][(__bridge NSString *)kCFBundleIdentifierKey], [[NSBundle mainBundle] infoDictionary][@"CFBundleShortVersionString"] ?: [[NSBundle mainBundle] infoDictionary][(__bridge NSString *)kCFBundleVersionKey], [[RedDevice currentDevice] model], [[RedDevice currentDevice] systemVersion], UITraitCollection.currentTraitCollection.displayScale]; #elif SD_UIKIT userAgent = [NSString stringWithFormat:@"%@/%@ (%@; iOS %@; Scale/%0.2f)", [[NSBundle mainBundle] infoDictionary][(__bridge NSString *)kCFBundleExecutableKey] ?: [[NSBundle mainBundle] infoDictionary][(__bridge NSString *)kCFBundleIdentifierKey], [[NSBundle mainBundle] infoDictionary][@"CFBundleShortVersionString"] ?: [[NSBundle mainBundle] infoDictionary][(__bridge NSString *)kCFBundleVersionKey], [[RedDevice currentDevice] model], [[RedDevice currentDevice] systemVersion], [[UIScreen mainScreen] scale]]; #elif SD_WATCH userAgent = [NSString stringWithFormat:@"%@/%@ (%@; watchOS %@; Scale/%0.2f)", [[NSBundle mainBundle] infoDictionary][(__bridge NSString *)kCFBundleExecutableKey] ?: [[NSBundle mainBundle] infoDictionary][(__bridge NSString *)kCFBundleIdentifierKey], [[NSBundle mainBundle] infoDictionary][@"CFBundleShortVersionString"] ?: [[NSBundle mainBundle] infoDictionary][(__bridge NSString *)kCFBundleVersionKey], [[WKInterfaceDevice currentDevice] model], [[WKInterfaceDevice currentDevice] systemVersion], [[WKInterfaceDevice currentDevice] screenScale]]; #elif SD_MAC userAgent = [NSString stringWithFormat:@"%@/%@ (Mac OS X %@)", [[NSBundle mainBundle] infoDictionary][(__bridge NSString *)kCFBundleExecutableKey] ?: [[NSBundle mainBundle] infoDictionary][(__bridge NSString *)kCFBundleIdentifierKey], [[NSBundle mainBundle] infoDictionary][@"CFBundleShortVersionString"] ?: [[NSBundle mainBundle] infoDictionary][(__bridge NSString *)kCFBundleVersionKey], [[NSProcessInfo processInfo] operatingSystemVersionString]]; #endif if (userAgent) { if (![userAgent canBeConvertedToEncoding:NSASCIIStringEncoding]) { NSMutableString *mutableUserAgent = [userAgent mutableCopy]; if (CFStringTransform((__bridge CFMutableStringRef)(mutableUserAgent), NULL, (__bridge CFStringRef)@"Any-Latin; Latin-ASCII; [:^ASCII:] Remove", false)) { userAgent = mutableUserAgent; } } headerDictionary[@"User-Agent"] = userAgent; } headerDictionary[@"Accept"] = @"image/*,*/*;q=0.8"; _HTTPHeaders = headerDictionary; SD_LOCK_INIT(_HTTPHeadersLock); SD_LOCK_INIT(_operationsLock); NSURLSessionConfiguration *sessionConfiguration = _config.sessionConfiguration; if (!sessionConfiguration) { sessionConfiguration = [NSURLSessionConfiguration defaultSessionConfiguration]; } _session = [NSURLSession sessionWithConfiguration:sessionConfiguration delegate:self delegateQueue:nil]; } return self; } - (void)dealloc { [self.downloadQueue cancelAllOperations]; [self.config removeObserver:self forKeyPath:NSStringFromSelector(@selector(maxConcurrentDownloads)) context:SDWebImageDownloaderContext]; [self.session invalidateAndCancel]; self.session = nil; } - (void)invalidateSessionAndCancel:(BOOL)cancelPendingOperations { if (self == [SDWebImageDownloader sharedDownloader]) { return; } if (cancelPendingOperations) { [self.session invalidateAndCancel]; } else { [self.session finishTasksAndInvalidate]; } } - (void)setValue:(nullable NSString *)value forHTTPHeaderField:(nullable NSString *)field { if (!field) { return; } SD_LOCK(_HTTPHeadersLock); [self.HTTPHeaders setValue:value forKey:field]; SD_UNLOCK(_HTTPHeadersLock); } - (nullable NSString *)valueForHTTPHeaderField:(nullable NSString *)field { if (!field) { return nil; } SD_LOCK(_HTTPHeadersLock); NSString *value = [self.HTTPHeaders objectForKey:field]; SD_UNLOCK(_HTTPHeadersLock); return value; } - (nullable SDWebImageDownloadToken *)downloadImageWithURL:(Outer *)url completed:(SDWebImageDownloaderCompletedBlock)completedBlock { return [self downloadImageWithURL:url options:0 progress:nil completed:completedBlock]; } - (nullable SDWebImageDownloadToken *)downloadImageWithURL:(Outer *)url options:(SDWebImageDownloaderOptions)options progress:(SDWebImageDownloaderProgressBlock)progressBlock completed:(SDWebImageDownloaderCompletedBlock)completedBlock { return [self downloadImageWithURL:url options:options context:nil progress:progressBlock completed:completedBlock]; } - (nullable SDWebImageDownloadToken *)downloadImageWithURL:(nullable Outer *)url options:(SDWebImageDownloaderOptions)options context:(nullable SDWebImageContext *)context progress:(nullable SDWebImageDownloaderProgressBlock)progressBlock completed:(nullable SDWebImageDownloaderCompletedBlock)completedBlock { if (url == nil) { if (completedBlock) { NSError *error = [NSError errorWithDomain:SDWebImageErrorDomain code:SDWebImageErrorInvalidURL userInfo:@{NSLocalizedDescriptionKey : @"Image url is nil"}]; completedBlock(nil, nil, error, YES); } return nil; } id downloadOperationCancelToken; id cacheKeyFilter = context[SDWebImageContextCacheKeyFilter]; NSString *cacheKey; if (cacheKeyFilter) { cacheKey = [cacheKeyFilter cacheKeyForURL:url]; } else { cacheKey = url.absoluteString; } SDImageCoderOptions *decodeOptions = SDGetDecodeOptionsFromContext(context, [self.class imageOptionsFromDownloaderOptions:options], cacheKey); SD_LOCK(_operationsLock); NSOperation *operation = [self.URLOperations objectForKey:url]; BOOL shouldNotReuseOperation; if (operation) { @synchronized (operation) { shouldNotReuseOperation = operation.isFinished || operation.isCancelled; } } else { shouldNotReuseOperation = YES; } if (shouldNotReuseOperation) { operation = [self createDownloaderOperationWithUrl:url options:options context:context]; if (!operation) { SD_UNLOCK(_operationsLock); if (completedBlock) { NSError *error = [NSError errorWithDomain:SDWebImageErrorDomain code:SDWebImageErrorInvalidDownloadOperation userInfo:@{NSLocalizedDescriptionKey : @"Downloader operation is nil"}]; completedBlock(nil, nil, error, YES); } return nil; } @weakify(self); operation.completionBlock = ^{ @strongify(self); if (!self) { return; } SD_LOCK(self->_operationsLock); [self.URLOperations removeObjectForKey:url]; SD_UNLOCK(self->_operationsLock); }; [self.URLOperations setObject:operation forKey:url]; downloadOperationCancelToken = [operation addHandlersForProgress:progressBlock completed:completedBlock decodeOptions:decodeOptions]; [self.downloadQueue addOperation:operation]; } else { @synchronized (operation) { downloadOperationCancelToken = [operation addHandlersForProgress:progressBlock completed:completedBlock decodeOptions:decodeOptions]; } } SD_UNLOCK(_operationsLock); SDWebImageDownloadToken *token = [[SDWebImageDownloadToken alloc] initWithDownloadOperation:operation]; token.url = url; token.request = operation.request; token.downloadOperationCancelToken = downloadOperationCancelToken; return token; } #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wdeprecated-declarations" + (SDWebImageOptions)imageOptionsFromDownloaderOptions:(SDWebImageDownloaderOptions)downloadOptions { SDWebImageOptions options = 0; if (downloadOptions & SDWebImageDownloaderScaleDownLargeImages) options |= SDWebImageScaleDownLargeImages; if (downloadOptions & SDWebImageDownloaderDecodeFirstFrameOnly) options |= SDWebImageDecodeFirstFrameOnly; if (downloadOptions & SDWebImageDownloaderPreloadAllFrames) options |= SDWebImagePreloadAllFrames; if (downloadOptions & SDWebImageDownloaderAvoidDecodeImage) options |= SDWebImageAvoidDecodeImage; if (downloadOptions & SDWebImageDownloaderMatchAnimatedImageClass) options |= SDWebImageMatchAnimatedImageClass; return options; } #pragma clang diagnostic pop - (nullable NSOperation *)createDownloaderOperationWithUrl:(nonnull Outer *)url options:(SDWebImageDownloaderOptions)options context:(nullable SDWebImageContext *)context { NSTimeInterval timeoutInterval = self.config.downloadTimeout; if (timeoutInterval == 0.0) { timeoutInterval = 15.0; } NSURLRequestCachePolicy cachePolicy = options & SDWebImageDownloaderUseNSURLCache ? NSURLRequestUseProtocolCachePolicy : NSURLRequestReloadIgnoringLocalCacheData; NSMutableURLRequest *mutableRequest = [[NSMutableURLRequest alloc] initWithURL:url cachePolicy:cachePolicy timeoutInterval:timeoutInterval]; mutableRequest.HTTPShouldHandleCookies = SD_OPTIONS_CONTAINS(options, SDWebImageDownloaderHandleCookies); mutableRequest.HTTPShouldUsePipelining = YES; SD_LOCK(_HTTPHeadersLock); mutableRequest.allHTTPHeaderFields = self.HTTPHeaders; SD_UNLOCK(_HTTPHeadersLock); SDWebImageMutableContext *mutableContext; if (context) { mutableContext = [context mutableCopy]; } else { mutableContext = [NSMutableDictionary dictionary]; } id requestModifier; if ([context valueForKey:SDWebImageContextDownloadRequestModifier]) { requestModifier = [context valueForKey:SDWebImageContextDownloadRequestModifier]; } else { requestModifier = self.requestModifier; } NSURLRequest *request; if (requestModifier) { NSURLRequest *modifiedRequest = [requestModifier modifiedRequestWithRequest:[mutableRequest copy]]; if (!modifiedRequest) { return nil; } else { request = [modifiedRequest copy]; } } else { request = [mutableRequest copy]; } id responseModifier; if ([context valueForKey:SDWebImageContextDownloadResponseModifier]) { responseModifier = [context valueForKey:SDWebImageContextDownloadResponseModifier]; } else { responseModifier = self.responseModifier; } if (responseModifier) { mutableContext[SDWebImageContextDownloadResponseModifier] = responseModifier; } id decryptor; if ([context valueForKey:SDWebImageContextDownloadDecryptor]) { decryptor = [context valueForKey:SDWebImageContextDownloadDecryptor]; } else { decryptor = self.decryptor; } if (decryptor) { mutableContext[SDWebImageContextDownloadDecryptor] = decryptor; } context = [mutableContext copy]; Class operationClass = self.config.operationClass; if (!operationClass) { operationClass = [SDWebImageDownloaderOperation class]; } NSOperation *operation = [[operationClass alloc] initWithRequest:request inSession:self.session options:options context:context]; if ([operation respondsToSelector:@selector(setCredential:)]) { if (self.config.urlCredential) { operation.credential = self.config.urlCredential; } else if (self.config.username && self.config.password) { operation.credential = [NSURLCredential credentialWithUser:self.config.username password:self.config.password persistence:NSURLCredentialPersistenceForSession]; } } if ([operation respondsToSelector:@selector(setMinimumProgressInterval:)]) { operation.minimumProgressInterval = MIN(MAX(self.config.minimumProgressInterval, 0), 1); } if ([operation respondsToSelector:@selector(setAcceptableStatusCodes:)]) { operation.acceptableStatusCodes = self.config.acceptableStatusCodes; } if ([operation respondsToSelector:@selector(setAcceptableContentTypes:)]) { operation.acceptableContentTypes = self.config.acceptableContentTypes; } if (options & SDWebImageDownloaderHighPriority) { operation.queuePriority = NSOperationQueuePriorityHigh; } else if (options & SDWebImageDownloaderLowPriority) { operation.queuePriority = NSOperationQueuePriorityLow; } if (self.config.executionOrder == SDWebImageDownloaderLIFOExecutionOrder) { for (NSOperation *pendingOperation in self.downloadQueue.operations) { [pendingOperation addDependency:operation]; } } return operation; } - (void)cancelAllDownloads { [self.downloadQueue cancelAllOperations]; } - (BOOL)isSuspended { return self.downloadQueue.isSuspended; } - (void)setSuspended:(BOOL)suspended { self.downloadQueue.suspended = suspended; } - (NSUInteger)currentDownloadCount { return self.downloadQueue.operationCount; } - (NSURLSessionConfiguration *)sessionConfiguration { return self.session.configuration; } - (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary *)change context:(void *)context { if (context == SDWebImageDownloaderContext) { if ([keyPath isEqualToString:NSStringFromSelector(@selector(maxConcurrentDownloads))]) { self.downloadQueue.maxConcurrentOperationCount = self.config.maxConcurrentDownloads; } } else { [super observeValueForKeyPath:keyPath ofObject:object change:change context:context]; } } - (NSOperation *)operationWithTask:(NSURLSessionTask *)task { NSOperation *returnOperation = nil; for (NSOperation *operation in self.downloadQueue.operations) { if ([operation respondsToSelector:@selector(dataTask)]) { NSURLSessionTask *operationTask; @synchronized (operation) { operationTask = operation.dataTask; } if (operationTask.taskIdentifier == task.taskIdentifier) { returnOperation = operation; break; } } } return returnOperation; } - (void)URLSession:(NSURLSession *)session dataTask:(NSURLSessionDataTask *)dataTask didReceiveResponse:(NSURLResponse *)response completionHandler:(void (^)(NSURLSessionResponseDisposition disposition))completionHandler { NSOperation *dataOperation = [self operationWithTask:dataTask]; if ([dataOperation respondsToSelector:@selector(URLSession:dataTask:didReceiveResponse:completionHandler:)]) { [dataOperation URLSession:session dataTask:dataTask didReceiveResponse:response completionHandler:completionHandler]; } else { if (completionHandler) { completionHandler(NSURLSessionResponseAllow); } } } - (void)URLSession:(NSURLSession *)session dataTask:(NSURLSessionDataTask *)dataTask didReceiveData:(NSData *)data { NSOperation *dataOperation = [self operationWithTask:dataTask]; if ([dataOperation respondsToSelector:@selector(URLSession:dataTask:didReceiveData:)]) { [dataOperation URLSession:session dataTask:dataTask didReceiveData:data]; } } - (void)URLSession:(NSURLSession *)session dataTask:(NSURLSessionDataTask *)dataTask willCacheResponse:(NSCachedURLResponse *)proposedResponse completionHandler:(void (^)(NSCachedURLResponse *cachedResponse))completionHandler { NSOperation *dataOperation = [self operationWithTask:dataTask]; if ([dataOperation respondsToSelector:@selector(URLSession:dataTask:willCacheResponse:completionHandler:)]) { [dataOperation URLSession:session dataTask:dataTask willCacheResponse:proposedResponse completionHandler:completionHandler]; } else { if (completionHandler) { completionHandler(proposedResponse); } } } - (void)URLSession:(NSURLSession *)session task:(NSURLSessionTask *)task didCompleteWithError:(NSError *)error { NSOperation *dataOperation = [self operationWithTask:task]; if ([dataOperation respondsToSelector:@selector(URLSession:task:didCompleteWithError:)]) { [dataOperation URLSession:session task:task didCompleteWithError:error]; } } - (void)URLSession:(NSURLSession *)session task:(NSURLSessionTask *)task willPerformHTTPRedirection:(NSHTTPURLResponse *)response newRequest:(NSURLRequest *)request completionHandler:(void (^)(NSURLRequest * _Nullable))completionHandler { NSOperation *dataOperation = [self operationWithTask:task]; if ([dataOperation respondsToSelector:@selector(URLSession:task:willPerformHTTPRedirection:newRequest:completionHandler:)]) { [dataOperation URLSession:session task:task willPerformHTTPRedirection:response newRequest:request completionHandler:completionHandler]; } else { if (completionHandler) { completionHandler(request); } } } - (void)URLSession:(NSURLSession *)session task:(NSURLSessionTask *)task didReceiveChallenge:(NSURLAuthenticationChallenge *)challenge completionHandler:(void (^)(NSURLSessionAuthChallengeDisposition disposition, NSURLCredential *credential))completionHandler { NSOperation *dataOperation = [self operationWithTask:task]; if ([dataOperation respondsToSelector:@selector(URLSession:task:didReceiveChallenge:completionHandler:)]) { [dataOperation URLSession:session task:task didReceiveChallenge:challenge completionHandler:completionHandler]; } else { if (completionHandler) { completionHandler(NSURLSessionAuthChallengePerformDefaultHandling, nil); } } } - (void)URLSession:(NSURLSession *)session task:(NSURLSessionTask *)task didFinishCollectingMetrics:(NSURLSessionTaskMetrics *)metrics API_AVAILABLE(macos(10.12), ios(10.0), watchos(3.0), tvos(10.0)) { NSOperation *dataOperation = [self operationWithTask:task]; if ([dataOperation respondsToSelector:@selector(URLSession:task:didFinishCollectingMetrics:)]) { [dataOperation URLSession:session task:task didFinishCollectingMetrics:metrics]; } } @end @implementation SDWebImageDownloadToken - (void)dealloc { [[NSNotificationCenter defaultCenter] removeObserver:self name:SDWebImageDownloadReceiveResponseNotification object:nil]; [[NSNotificationCenter defaultCenter] removeObserver:self name:SDWebImageDownloadStopNotification object:nil]; } - (instancetype)initWithDownloadOperation:(NSOperation *)downloadOperation { self = [super init]; if (self) { _downloadOperation = downloadOperation; [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(downloadDidReceiveResponse:) name:SDWebImageDownloadReceiveResponseNotification object:nil]; [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(downloadDidStop:) name:SDWebImageDownloadStopNotification object:nil]; } return self; } - (void)downloadDidReceiveResponse:(NSNotification *)notification { NSOperation *downloadOperation = notification.object; if (downloadOperation && downloadOperation == self.downloadOperation) { self.response = downloadOperation.response; } } - (void)downloadDidStop:(NSNotification *)notification { NSOperation *downloadOperation = notification.object; if (downloadOperation && downloadOperation == self.downloadOperation) { if ([downloadOperation respondsToSelector:@selector(metrics)]) { if (@available(iOS 10.0, tvOS 10.0, macOS 10.12, watchOS 3.0, *)) { self.metrics = downloadOperation.metrics; } } } } - (void)cancel { @synchronized (self) { if (self.isCancelled) { return; } self.cancelled = YES; [self.downloadOperation cancel:self.downloadOperationCancelToken]; self.downloadOperationCancelToken = nil; } } @end @implementation SDWebImageDownloader (SDImageLoader) - (BOOL)canRequestImageForURL:(Outer *)url { return [self canRequestImageForURL:url options:0 context:nil]; } - (BOOL)canRequestImageForURL:(Outer *)url options:(SDWebImageOptions)options context:(SDWebImageContext *)context { if (!url) { return NO; } return YES; } #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wdeprecated-declarations" - (id)requestImageWithURL:(Outer *)url options:(SDWebImageOptions)options context:(SDWebImageContext *)context progress:(SDImageLoaderProgressBlock)progressBlock completed:(SDImageLoaderCompletedBlock)completedBlock { UIImage *cachedImage = context[SDWebImageContextLoaderCachedImage]; SDWebImageDownloaderOptions downloaderOptions = 0; if (options & SDWebImageLowPriority) downloaderOptions |= SDWebImageDownloaderLowPriority; if (options & SDWebImageProgressiveLoad) downloaderOptions |= SDWebImageDownloaderProgressiveLoad; 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; if (options & SDWebImageAvoidDecodeImage) downloaderOptions |= SDWebImageDownloaderAvoidDecodeImage; if (options & SDWebImageDecodeFirstFrameOnly) downloaderOptions |= SDWebImageDownloaderDecodeFirstFrameOnly; if (options & SDWebImagePreloadAllFrames) downloaderOptions |= SDWebImageDownloaderPreloadAllFrames; if (options & SDWebImageMatchAnimatedImageClass) downloaderOptions |= SDWebImageDownloaderMatchAnimatedImageClass; if (cachedImage && options & SDWebImageRefreshCached) { downloaderOptions &= ~SDWebImageDownloaderProgressiveLoad; downloaderOptions |= SDWebImageDownloaderIgnoreCachedResponse; } return [self downloadImageWithURL:url options:downloaderOptions context:context progress:progressBlock completed:completedBlock]; } #pragma clang diagnostic pop - (BOOL)shouldBlockFailedURLWithURL:(Outer *)url error:(NSError *)error { return [self shouldBlockFailedURLWithURL:url error:error options:0 context:nil]; } - (BOOL)shouldBlockFailedURLWithURL:(Outer *)url error:(NSError *)error options:(SDWebImageOptions)options context:(SDWebImageContext *)context { BOOL shouldBlockFailedURL; if ([error.domain isEqualToString:SDWebImageErrorDomain]) { shouldBlockFailedURL = ( error.code == SDWebImageErrorInvalidURL || error.code == SDWebImageErrorBadImageData); } else if ([error.domain isEqualToString:NSURLErrorDomain]) { shouldBlockFailedURL = ( error.code != NSURLErrorNotConnectedToInternet && error.code != NSURLErrorCancelled && error.code != NSURLErrorTimedOut && error.code != NSURLErrorInternationalRoamingOff && error.code != NSURLErrorDataNotAllowed && error.code != NSURLErrorCannotFindHost && error.code != NSURLErrorCannotConnectToHost && error.code != NSURLErrorNetworkConnectionLost); } else { shouldBlockFailedURL = NO; } return shouldBlockFailedURL; } @end