/*
|
* 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 "SDWebImageDownloader.h"
|
#import "SDWebImageDownloaderOperation.h"
|
#import <ImageIO/ImageIO.h>
|
|
static NSString *const kProgressCallbackKey = @"progress";
|
static NSString *const kCompletedCallbackKey = @"completed";
|
|
@interface SDWebImageDownloader () <NSURLSessionTaskDelegate, NSURLSessionDataDelegate>
|
|
@property (strong, nonatomic) NSOperationQueue *downloadQueue;
|
@property (weak, nonatomic) NSOperation *lastAddedOperation;
|
@property (assign, nonatomic) Class operationClass;
|
@property (strong, nonatomic) NSMutableDictionary *URLCallbacks;
|
@property (strong, nonatomic) NSMutableDictionary *HTTPHeaders;
|
// This queue is used to serialize the handling of the network responses of all the download operation in a single queue
|
@property (SDDispatchQueueSetterSementics, nonatomic) dispatch_queue_t barrierQueue;
|
|
// The session in which data tasks will run
|
@property (strong, nonatomic) NSURLSession *session;
|
|
@end
|
|
@implementation SDWebImageDownloader
|
|
+ (void)initialize {
|
// Bind SDNetworkActivityIndicator if available (download it here: http://github.com/rs/SDNetworkActivityIndicator )
|
// To use it, just add #import "SDNetworkActivityIndicator.h" in addition to the SDWebImage import
|
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
|
|
// Remove observer in case it was previously added.
|
[[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];
|
}
|
}
|
|
+ (SDWebImageDownloader *)sharedDownloader {
|
static dispatch_once_t once;
|
static id instance;
|
dispatch_once(&once, ^{
|
instance = [self new];
|
});
|
return instance;
|
}
|
|
- (id)init {
|
if ((self = [super init])) {
|
_operationClass = [SDWebImageDownloaderOperation class];
|
_shouldDecompressImages = YES;
|
_executionOrder = SDWebImageDownloaderFIFOExecutionOrder;
|
_downloadQueue = [NSOperationQueue new];
|
_downloadQueue.maxConcurrentOperationCount = 6;
|
_URLCallbacks = [NSMutableDictionary new];
|
#ifdef SD_WEBP
|
_HTTPHeaders = [@{@"Accept": @"image/webp,image/*;q=0.8"} mutableCopy];
|
#else
|
_HTTPHeaders = [@{@"Accept": @"image/*;q=0.8"} mutableCopy];
|
#endif
|
_barrierQueue = dispatch_queue_create("com.hackemist.SDWebImageDownloaderBarrierQueue", DISPATCH_QUEUE_CONCURRENT);
|
_downloadTimeout = 15.0;
|
|
NSURLSessionConfiguration *sessionConfig = [NSURLSessionConfiguration defaultSessionConfiguration];
|
sessionConfig.timeoutIntervalForRequest = _downloadTimeout;
|
|
/**
|
* Create the session for this task
|
* We send nil as delegate queue so that the session creates a serial operation queue for performing all delegate
|
* method calls and completion handler calls.
|
*/
|
self.session = [NSURLSession sessionWithConfiguration:sessionConfig
|
delegate:self
|
delegateQueue:nil];
|
}
|
return self;
|
}
|
|
- (void)dealloc {
|
[self.session invalidateAndCancel];
|
self.session = nil;
|
|
[self.downloadQueue cancelAllOperations];
|
SDDispatchQueueRelease(_barrierQueue);
|
}
|
|
- (void)setValue:(NSString *)value forHTTPHeaderField:(NSString *)field {
|
if (value) {
|
self.HTTPHeaders[field] = value;
|
}
|
else {
|
[self.HTTPHeaders removeObjectForKey:field];
|
}
|
}
|
|
- (NSString *)valueForHTTPHeaderField:(NSString *)field {
|
return self.HTTPHeaders[field];
|
}
|
|
- (void)setMaxConcurrentDownloads:(NSInteger)maxConcurrentDownloads {
|
_downloadQueue.maxConcurrentOperationCount = maxConcurrentDownloads;
|
}
|
|
- (NSUInteger)currentDownloadCount {
|
return _downloadQueue.operationCount;
|
}
|
|
- (NSInteger)maxConcurrentDownloads {
|
return _downloadQueue.maxConcurrentOperationCount;
|
}
|
|
- (void)setOperationClass:(Class)operationClass {
|
_operationClass = operationClass ?: [SDWebImageDownloaderOperation class];
|
}
|
|
- (id <SDWebImageOperation>)downloadImageWithURL:(NSURL *)url options:(SDWebImageDownloaderOptions)options progress:(SDWebImageDownloaderProgressBlock)progressBlock completed:(SDWebImageDownloaderCompletedBlock)completedBlock {
|
__block SDWebImageDownloaderOperation *operation;
|
__weak __typeof(self)wself = self;
|
|
[self addProgressCallback:progressBlock completedBlock:completedBlock forURL:url createCallback:^{
|
NSTimeInterval timeoutInterval = wself.downloadTimeout;
|
if (timeoutInterval == 0.0) {
|
timeoutInterval = 15.0;
|
}
|
|
// In order to prevent from potential duplicate caching (NSURLCache + SDImageCache) we disable the cache for image requests if told otherwise
|
NSMutableURLRequest *request = [[NSMutableURLRequest alloc] initWithURL:url cachePolicy:(options & SDWebImageDownloaderUseNSURLCache ? NSURLRequestUseProtocolCachePolicy : NSURLRequestReloadIgnoringLocalCacheData) timeoutInterval:timeoutInterval];
|
request.HTTPShouldHandleCookies = (options & SDWebImageDownloaderHandleCookies);
|
request.HTTPShouldUsePipelining = YES;
|
if (wself.headersFilter) {
|
request.allHTTPHeaderFields = wself.headersFilter(url, [wself.HTTPHeaders copy]);
|
}
|
else {
|
request.allHTTPHeaderFields = wself.HTTPHeaders;
|
}
|
operation = [[wself.operationClass alloc] initWithRequest:request
|
inSession:self.session
|
options:options
|
progress:^(NSInteger receivedSize, NSInteger expectedSize) {
|
SDWebImageDownloader *sself = wself;
|
if (!sself) return;
|
__block NSArray *callbacksForURL;
|
dispatch_sync(sself.barrierQueue, ^{
|
callbacksForURL = [sself.URLCallbacks[url] copy];
|
});
|
for (NSDictionary *callbacks in callbacksForURL) {
|
dispatch_async(dispatch_get_main_queue(), ^{
|
SDWebImageDownloaderProgressBlock callback = callbacks[kProgressCallbackKey];
|
if (callback) callback(receivedSize, expectedSize);
|
});
|
}
|
}
|
completed:^(UIImage *image, NSData *data, NSError *error, BOOL finished) {
|
SDWebImageDownloader *sself = wself;
|
if (!sself) return;
|
__block NSArray *callbacksForURL;
|
dispatch_barrier_sync(sself.barrierQueue, ^{
|
callbacksForURL = [sself.URLCallbacks[url] copy];
|
if (finished) {
|
[sself.URLCallbacks removeObjectForKey:url];
|
}
|
});
|
for (NSDictionary *callbacks in callbacksForURL) {
|
SDWebImageDownloaderCompletedBlock callback = callbacks[kCompletedCallbackKey];
|
if (callback) callback(image, data, error, finished);
|
}
|
}
|
cancelled:^{
|
SDWebImageDownloader *sself = wself;
|
if (!sself) return;
|
dispatch_barrier_async(sself.barrierQueue, ^{
|
[sself.URLCallbacks removeObjectForKey:url];
|
});
|
}];
|
operation.shouldDecompressImages = wself.shouldDecompressImages;
|
|
if (wself.urlCredential) {
|
operation.credential = wself.urlCredential;
|
} else if (wself.username && wself.password) {
|
operation.credential = [NSURLCredential credentialWithUser:wself.username password:wself.password persistence:NSURLCredentialPersistenceForSession];
|
}
|
|
if (options & SDWebImageDownloaderHighPriority) {
|
operation.queuePriority = NSOperationQueuePriorityHigh;
|
} else if (options & SDWebImageDownloaderLowPriority) {
|
operation.queuePriority = NSOperationQueuePriorityLow;
|
}
|
|
[wself.downloadQueue addOperation:operation];
|
if (wself.executionOrder == SDWebImageDownloaderLIFOExecutionOrder) {
|
// Emulate LIFO execution order by systematically adding new operations as last operation's dependency
|
[wself.lastAddedOperation addDependency:operation];
|
wself.lastAddedOperation = operation;
|
}
|
}];
|
|
return operation;
|
}
|
|
- (void)addProgressCallback:(SDWebImageDownloaderProgressBlock)progressBlock completedBlock:(SDWebImageDownloaderCompletedBlock)completedBlock forURL:(NSURL *)url createCallback:(SDWebImageNoParamsBlock)createCallback {
|
// The URL will be used as the key to the callbacks dictionary so it cannot be nil. If it is nil immediately call the completed block with no image or data.
|
if (url == nil) {
|
if (completedBlock != nil) {
|
completedBlock(nil, nil, nil, NO);
|
}
|
return;
|
}
|
|
dispatch_barrier_sync(self.barrierQueue, ^{
|
BOOL first = NO;
|
if (!self.URLCallbacks[url]) {
|
self.URLCallbacks[url] = [NSMutableArray new];
|
first = YES;
|
}
|
|
// Handle single download of simultaneous download request for the same URL
|
NSMutableArray *callbacksForURL = self.URLCallbacks[url];
|
NSMutableDictionary *callbacks = [NSMutableDictionary new];
|
if (progressBlock) callbacks[kProgressCallbackKey] = [progressBlock copy];
|
if (completedBlock) callbacks[kCompletedCallbackKey] = [completedBlock copy];
|
[callbacksForURL addObject:callbacks];
|
self.URLCallbacks[url] = callbacksForURL;
|
|
if (first) {
|
createCallback();
|
}
|
});
|
}
|
|
- (void)setSuspended:(BOOL)suspended {
|
[self.downloadQueue setSuspended:suspended];
|
}
|
|
- (void)cancelAllDownloads {
|
[self.downloadQueue cancelAllOperations];
|
}
|
|
#pragma mark Helper methods
|
|
- (SDWebImageDownloaderOperation *)operationWithTask:(NSURLSessionTask *)task {
|
SDWebImageDownloaderOperation *returnOperation = nil;
|
for (SDWebImageDownloaderOperation *operation in self.downloadQueue.operations) {
|
if (operation.dataTask.taskIdentifier == task.taskIdentifier) {
|
returnOperation = operation;
|
break;
|
}
|
}
|
return returnOperation;
|
}
|
|
#pragma mark NSURLSessionDataDelegate
|
|
- (void)URLSession:(NSURLSession *)session
|
dataTask:(NSURLSessionDataTask *)dataTask
|
didReceiveResponse:(NSURLResponse *)response
|
completionHandler:(void (^)(NSURLSessionResponseDisposition disposition))completionHandler {
|
|
// Identify the operation that runs this task and pass it the delegate method
|
SDWebImageDownloaderOperation *dataOperation = [self operationWithTask:dataTask];
|
|
[dataOperation URLSession:session dataTask:dataTask didReceiveResponse:response completionHandler:completionHandler];
|
}
|
|
- (void)URLSession:(NSURLSession *)session dataTask:(NSURLSessionDataTask *)dataTask didReceiveData:(NSData *)data {
|
|
// Identify the operation that runs this task and pass it the delegate method
|
SDWebImageDownloaderOperation *dataOperation = [self operationWithTask:dataTask];
|
|
[dataOperation URLSession:session dataTask:dataTask didReceiveData:data];
|
}
|
|
- (void)URLSession:(NSURLSession *)session
|
dataTask:(NSURLSessionDataTask *)dataTask
|
willCacheResponse:(NSCachedURLResponse *)proposedResponse
|
completionHandler:(void (^)(NSCachedURLResponse *cachedResponse))completionHandler {
|
|
// Identify the operation that runs this task and pass it the delegate method
|
SDWebImageDownloaderOperation *dataOperation = [self operationWithTask:dataTask];
|
|
[dataOperation URLSession:session dataTask:dataTask willCacheResponse:proposedResponse completionHandler:completionHandler];
|
}
|
|
#pragma mark NSURLSessionTaskDelegate
|
|
- (void)URLSession:(NSURLSession *)session task:(NSURLSessionTask *)task didCompleteWithError:(NSError *)error {
|
// Identify the operation that runs this task and pass it the delegate method
|
SDWebImageDownloaderOperation *dataOperation = [self operationWithTask:task];
|
|
[dataOperation URLSession:session task:task didCompleteWithError:error];
|
}
|
|
- (void)URLSession:(NSURLSession *)session task:(NSURLSessionTask *)task didReceiveChallenge:(NSURLAuthenticationChallenge *)challenge completionHandler:(void (^)(NSURLSessionAuthChallengeDisposition disposition, NSURLCredential *credential))completionHandler {
|
|
// Identify the operation that runs this task and pass it the delegate method
|
SDWebImageDownloaderOperation *dataOperation = [self operationWithTask:task];
|
|
[dataOperation URLSession:session task:task didReceiveChallenge:challenge completionHandler:completionHandler];
|
}
|
|
@end
|
