1 typedef NS_OPTIONS(NSUInteger, SDWebImageDownloaderOptions) {
 2     SDWebImageDownloaderLowPriority = 1 << 0,
 3     SDWebImageDownloaderProgressiveDownload = 1 << 1,
 4
 5     /**
 6      * By default, request prevent the use of NSURLCache. With this flag, NSURLCache
 7      * is used with default policies.
 8      */
 9     SDWebImageDownloaderUseNSURLCache = 1 << 2,
10
11     /**
12      * Call completion block with nil image/imageData if the image was read from NSURLCache
13      * (to be combined with `SDWebImageDownloaderUseNSURLCache`).
14      */
15
16     SDWebImageDownloaderIgnoreCachedResponse = 1 << 3,
17     /**
18      * In iOS 4+, continue the download of the image if the app goes to background. This is achieved by asking the system for
19      * extra time in background to let the request finish. If the background task expires the operation will be cancelled.
20      */
21
22     SDWebImageDownloaderContinueInBackground = 1 << 4,
23
24     /**
25      * Handles cookies stored in NSHTTPCookieStore by setting
26      * NSMutableURLRequest.HTTPShouldHandleCookies = YES;
27      */
28     SDWebImageDownloaderHandleCookies = 1 << 5,
29
30     /**
31      * Enable to allow untrusted SSL certificates.
32      * Useful for testing purposes. Use with caution in production.
33      */
34     SDWebImageDownloaderAllowInvalidSSLCertificates = 1 << 6,
35
36     /**
37      * Put the image in the high priority queue.
38      */
39     SDWebImageDownloaderHighPriority = 1 << 7,
40
41     /**
42      * Scale down the image
43      */
44     SDWebImageDownloaderScaleDownLargeImages = 1 << 8,
45 };

1 self.option & SDWebImageDownloaderIgnoreCacheResponse

 1 typedef NS_ENUM(NSInteger, SDWebImageDownloaderExecutionOrder) {
 2     /**
 3      * Default value. All download operations will execute in queue style (first-in-first-out).
 4      */
 5     SDWebImageDownloaderFIFOExecutionOrder,
 6
 7     /**
 8      * All download operations will execute in stack style (last-in-first-out).
 9      */
10     SDWebImageDownloaderLIFOExecutionOrder
11 };

1 extern NSString * _Nonnull const SDWebImageDownloadStartNotification;
2 extern NSString * _Nonnull const SDWebImageDownloadStopNotification;

1 NSString *const SDWebImageDownloadStartNotification = @"SDWebImageDownloadStartNotification";
2 NSString *const SDWebImageDownloadStopNotification = @"SDWebImageDownloadStopNotification";

1 typedef void(^SDWebImageDownloaderProgressBlock)(NSInteger receivedSize, NSInteger expectedSize, NSURL * _Nullable targetURL);
2
3 typedef void(^SDWebImageDownloaderCompletedBlock)(UIImage * _Nullable image, NSData * _Nullable data, NSError * _Nullable error, BOOL finished);

1 typedef NSDictionary<NSString *, NSString *> SDHTTPHeadersDictionary;
2 typedef NSMutableDictionary<NSString *, NSString *> SDHTTPHeadersMutableDictionary;

1 typedef SDHTTPHeadersDictionary * _Nullable (^SDWebImageDownloaderHeadersFilterBlock)(NSURL * _Nullable url, SDHTTPHeadersDictionary * _Nullable headers);

1 @interface SDWebImageDownloadToken : NSObject
2
3 @property (nonatomic, strong, nullable) NSURL *url;
4 @property (nonatomic, strong, nullable) id downloadOperationCancelToken;
5
6 @end

1 /**
2  * Asynchronous downloader dedicated and optimized for image loading.
3  */
4 @interface SDWebImageDownloader : NSObject

1 /**
2  * Decompressing images that are downloaded and cached can improve performance but can consume lot of memory.
3  * Defaults to YES. Set this to NO if you are experiencing a crash due to excessive memory consumption.
4  */
5 @property (assign, nonatomic) BOOL shouldDecompressImages;

1 /**
2  *  The maximum number of concurrent downloads
3  */
4 @property (assign, nonatomic) NSInteger maxConcurrentDownloads;

1 /**
2  * Shows the current amount of downloads that still need to be downloaded
3  */
4 @property (readonly, nonatomic) NSUInteger currentDownloadCount;

1 /**
2  *  The timeout value (in seconds) for the download operation. Default: 15.0.
3  */
4 @property (assign, nonatomic) NSTimeInterval downloadTimeout;

1 /**
2  * Changes download operations execution order. Default value is `SDWebImageDownloaderFIFOExecutionOrder`.
3  */
4 @property (assign, nonatomic) SDWebImageDownloaderExecutionOrder executionOrder;

1 /**
2  *  Singleton method, returns the shared instance
3  *
4  *  @return global shared instance of downloader class
5  */
6 + (nonnull instancetype)sharedDownloader;

1 /**
2  *  Set the default URL credential to be set for request operations.
3  */
4 @property (strong, nonatomic, nullable) NSURLCredential *urlCredential;

1 /**
2  * Set username
3  */
4 @property (strong, nonatomic, nullable) NSString *username;
5
6 /**
7  * Set password
8  */
9 @property (strong, nonatomic, nullable) NSString *password;

1 /**
2  * Set filter to pick headers for downloading image HTTP request.
3  *
4  * This block will be invoked for each downloading image request, returned
5  * NSDictionary will be used as headers in corresponding HTTP request.
6  */
7 @property (nonatomic, copy, nullable) SDWebImageDownloaderHeadersFilterBlock headersFilter;

1 /**
2  * Creates an instance of a downloader with specified session configuration.
3  * *Note*: `timeoutIntervalForRequest` is going to be overwritten.
4  * @return new instance of downloader class
5  */
6 - (nonnull instancetype)initWithSessionConfiguration:(nullable NSURLSessionConfiguration *)sessionConfiguration NS_DESIGNATED_INITIALIZER;

1 /**
2  * Set a value for a HTTP header to be appended to each download HTTP request.
3  *
4  * @param value The value for the header field. Use `nil` value to remove the header.
5  * @param field The name of the header field to set.
6  */
7 - (void)setValue:(nullable NSString *)value forHTTPHeaderField:(nullable NSString *)field;

1 /**
2  * Returns the value of the specified HTTP header field.
3  *
4  * @return The value associated with the header field field, or `nil` if there is no corresponding header field.
5  */
6 - (nullable NSString *)valueForHTTPHeaderField:(nullable NSString *)field;

1 /**
2  * Sets a subclass of `SDWebImageDownloaderOperation` as the default
3  * `NSOperation` to be used each time SDWebImage constructs a request
4  * operation to download an image.
5  *
6  * @param operationClass The subclass of `SDWebImageDownloaderOperation` to set
7  *        as default. Passing `nil` will revert to `SDWebImageDownloaderOperation`.
8  */
9 - (void)setOperationClass:(nullable Class)operationClass;

 1 /**
 2  * Creates a SDWebImageDownloader async downloader instance with a given URL
 3  *
 4  * The delegate will be informed when the image is finish downloaded or an error has happen.
 5  *
 6  * @see SDWebImageDownloaderDelegate
 7  *
 8  * @param url            The URL to the image to download
 9  * @param options        The options to be used for this download
10  * @param progressBlock  A block called repeatedly while the image is downloading
11  *                       @note the progress block is executed on a background queue
12  * @param completedBlock A block called once the download is completed.
13  *                       If the download succeeded, the image parameter is set, in case of error,
14  *                       error parameter is set with the error. The last parameter is always YES
15  *                       if SDWebImageDownloaderProgressiveDownload isn't use. With the
16  *                       SDWebImageDownloaderProgressiveDownload option, this block is called
17  *                       repeatedly with the partial image object and the finished argument set to NO
18  *                       before to be called a last time with the full image and finished argument
19  *                       set to YES. In case of error, the finished argument is always YES.
20  *
21  * @return A token (SDWebImageDownloadToken) that can be passed to -cancel: to cancel this operation
22  */
23 - (nullable SDWebImageDownloadToken *)downloadImageWithURL:(nullable NSURL *)url
24                                                    options:(SDWebImageDownloaderOptions)options
25                                                   progress:(nullable SDWebImageDownloaderProgressBlock)progressBlock
26                                                  completed:(nullable SDWebImageDownloaderCompletedBlock)completedBlock;

1 /**
2  * Cancels a download that was previously queued using -downloadImageWithURL:options:progress:completed:
3  *
4  * @param token The token received from -downloadImageWithURL:options:progress:completed: that should be canceled.
5  */
6 - (void)cancel:(nullable SDWebImageDownloadToken *)token;

1 /**
2  * Sets the download queue suspension state
3  */
4 - (void)setSuspended:(BOOL)suspended;

1 /**
2  * Cancels all download operations in the queue
3  */
4 - (void)cancelAllDownloads;

 1 @implementation SDWebImageDownloadToken
 2 @end
 3
 4
 5 @interface SDWebImageDownloader () <NSURLSessionTaskDelegate, NSURLSessionDataDelegate>
 6
 7 @property (strong, nonatomic, nonnull) NSOperationQueue *downloadQueue;
 8 @property (weak, nonatomic, nullable) NSOperation *lastAddedOperation;
 9 @property (assign, nonatomic, nullable) Class operationClass;
10 @property (strong, nonatomic, nonnull) NSMutableDictionary<NSURL *, SDWebImageDownloaderOperation *> *URLOperations;
11 @property (strong, nonatomic, nullable) SDHTTPHeadersMutableDictionary *HTTPHeaders;
12 // This queue is used to serialize the handling of the network responses of all the download operation in a single queue
13 @property (SDDispatchQueueSetterSementics, nonatomic, nullable) dispatch_queue_t barrierQueue;
14
15 // The session in which data tasks will run
16 @property (strong, nonatomic) NSURLSession *session;
17
18 @end

 1 + (void)initialize {
 2     // Bind SDNetworkActivityIndicator if available (download it here: http://github.com/rs/SDNetworkActivityIndicator )
 3     // To use it, just add #import "SDNetworkActivityIndicator.h" in addition to the SDWebImage import
 4     if (NSClassFromString(@"SDNetworkActivityIndicator")) {
 5
 6 #pragma clang diagnostic push
 7 #pragma clang diagnostic ignored "-Warc-performSelector-leaks"
 8         id activityIndicator = [NSClassFromString(@"SDNetworkActivityIndicator") performSelector:NSSelectorFromString(@"sharedActivityIndicator")];
 9 #pragma clang diagnostic pop
10
11         // Remove observer in case it was previously added.
12         [[NSNotificationCenter defaultCenter] removeObserver:activityIndicator name:SDWebImageDownloadStartNotification object:nil];
13         [[NSNotificationCenter defaultCenter] removeObserver:activityIndicator name:SDWebImageDownloadStopNotification object:nil];
14
15         [[NSNotificationCenter defaultCenter] addObserver:activityIndicator
16                                                  selector:NSSelectorFromString(@"startActivity")
17                                                      name:SDWebImageDownloadStartNotification object:nil];
18         [[NSNotificationCenter defaultCenter] addObserver:activityIndicator
19                                                  selector:NSSelectorFromString(@"stopActivity")
20                                                      name:SDWebImageDownloadStopNotification object:nil];
21     }
22 }

1 + (nonnull instancetype)sharedDownloader {
2     static dispatch_once_t once;
3     static id instance;
4     dispatch_once(&once, ^{
5         instance = [self new];
6     });
7     return instance;
8 }

 1 - (nonnull instancetype)init {
 2     return [self initWithSessionConfiguration:[NSURLSessionConfiguration defaultSessionConfiguration]];
 3 }
 4
 5 - (nonnull instancetype)initWithSessionConfiguration:(nullable NSURLSessionConfiguration *)sessionConfiguration {
 6     if ((self = [super init])) {
 7         _operationClass = [SDWebImageDownloaderOperation class];
 8         _shouldDecompressImages = YES;
 9         _executionOrder = SDWebImageDownloaderFIFOExecutionOrder;
10         _downloadQueue = [NSOperationQueue new];
11         _downloadQueue.maxConcurrentOperationCount = 6;
12         _downloadQueue.name = @"com.hackemist.SDWebImageDownloader";
13         _URLOperations = [NSMutableDictionary new];
14 #ifdef SD_WEBP
15         _HTTPHeaders = [@{@"Accept": @"image/webp,image/*;q=0.8"} mutableCopy];
16 #else
17         _HTTPHeaders = [@{@"Accept": @"image/*;q=0.8"} mutableCopy];
18 #endif
19         _barrierQueue = dispatch_queue_create("com.hackemist.SDWebImageDownloaderBarrierQueue", DISPATCH_QUEUE_CONCURRENT);
20         _downloadTimeout = 15.0;
21
22         sessionConfiguration.timeoutIntervalForRequest = _downloadTimeout;
23
24         /**
25          *  Create the session for this task
26          *  We send nil as delegate queue so that the session creates a serial operation queue for performing all delegate
27          *  method calls and completion handler calls.
28          */
29         self.session = [NSURLSession sessionWithConfiguration:sessionConfiguration
30                                                      delegate:self
31                                                 delegateQueue:nil];
32     }
33     return self;
34 }

1 - (void)dealloc {
2     [self.session invalidateAndCancel];
3     self.session = nil;
4
5     [self.downloadQueue cancelAllOperations];
6     SDDispatchQueueRelease(_barrierQueue);
7 }

 1 - (void)setValue:(nullable NSString *)value forHTTPHeaderField:(nullable NSString *)field {
 2     if (value) {
 3         self.HTTPHeaders[field] = value;
 4     }
 5     else {
 6         [self.HTTPHeaders removeObjectForKey:field];
 7     }
 8 }
 9
10 - (nullable NSString *)valueForHTTPHeaderField:(nullable NSString *)field {
11     return self.HTTPHeaders[field];
12 }
13
14 - (void)setMaxConcurrentDownloads:(NSInteger)maxConcurrentDownloads {
15     _downloadQueue.maxConcurrentOperationCount = maxConcurrentDownloads;
16 }
17
18 - (NSUInteger)currentDownloadCount {
19     return _downloadQueue.operationCount;
20 }
21
22 - (NSInteger)maxConcurrentDownloads {
23     return _downloadQueue.maxConcurrentOperationCount;
24 }
25
26 - (void)setOperationClass:(nullable Class)operationClass {
27     if (operationClass && [operationClass isSubclassOfClass:[NSOperation class]] && [operationClass conformsToProtocol:@protocol(SDWebImageDownloaderOperationInterface)]) {
28         _operationClass = operationClass;
29     } else {
30         _operationClass = [SDWebImageDownloaderOperation class];
31     }
32 }

 1 - (nullable SDWebImageDownloadToken *)addProgressCallback:(SDWebImageDownloaderProgressBlock)progressBlock
 2                                            completedBlock:(SDWebImageDownloaderCompletedBlock)completedBlock
 3                                                    forURL:(nullable NSURL *)url
 4                                            createCallback:(SDWebImageDownloaderOperation *(^)())createCallback {
 5     // 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.
 6     if (url == nil) {
 7         if (completedBlock != nil) {
 8             completedBlock(nil, nil, nil, NO);
 9         }
10         return nil;
11     }
12
13     __block SDWebImageDownloadToken *token = nil;
14
15     dispatch_barrier_sync(self.barrierQueue, ^{
16         SDWebImageDownloaderOperation *operation = self.URLOperations[url];
17         if (!operation) {
18             operation = createCallback();
19             self.URLOperations[url] = operation;
20
21             __weak SDWebImageDownloaderOperation *woperation = operation;
22             operation.completionBlock = ^{
23               SDWebImageDownloaderOperation *soperation = woperation;
24               if (!soperation) return;
25               if (self.URLOperations[url] == soperation) {
26                   [self.URLOperations removeObjectForKey:url];
27               };
28             };
29         }
30         id downloadOperationCancelToken = [operation addHandlersForProgress:progressBlock completed:completedBlock];
31
32         token = [SDWebImageDownloadToken new];
33         token.url = url;
34         token.downloadOperationCancelToken = downloadOperationCancelToken;
35     });
36
37     return token;
38 }

 1 - (nullable SDWebImageDownloadToken *)downloadImageWithURL:(nullable NSURL *)url
 2                                                    options:(SDWebImageDownloaderOptions)options
 3                                                   progress:(nullable SDWebImageDownloaderProgressBlock)progressBlock
 4                                                  completed:(nullable SDWebImageDownloaderCompletedBlock)completedBlock {
 5     __weak SDWebImageDownloader *wself = self;
 6
 7     return [self addProgressCallback:progressBlock completedBlock:completedBlock forURL:url createCallback:^SDWebImageDownloaderOperation *{
 8         __strong __typeof (wself) sself = wself;
 9         NSTimeInterval timeoutInterval = sself.downloadTimeout;
10         if (timeoutInterval == 0.0) {
11             timeoutInterval = 15.0;
12         }
13
14         // In order to prevent from potential duplicate caching (NSURLCache + SDImageCache) we disable the cache for image requests if told otherwise
15         NSMutableURLRequest *request = [[NSMutableURLRequest alloc] initWithURL:url cachePolicy:(options & SDWebImageDownloaderUseNSURLCache ? NSURLRequestUseProtocolCachePolicy : NSURLRequestReloadIgnoringLocalCacheData) timeoutInterval:timeoutInterval];
16         request.HTTPShouldHandleCookies = (options & SDWebImageDownloaderHandleCookies);
17         request.HTTPShouldUsePipelining = YES;
18         if (sself.headersFilter) {
19             request.allHTTPHeaderFields = sself.headersFilter(url, [sself.HTTPHeaders copy]);
20         }
21         else {
22             request.allHTTPHeaderFields = sself.HTTPHeaders;
23         }
24         SDWebImageDownloaderOperation *operation = [[sself.operationClass alloc] initWithRequest:request inSession:sself.session options:options];
25         operation.shouldDecompressImages = sself.shouldDecompressImages;
26
27         if (sself.urlCredential) {
28             operation.credential = sself.urlCredential;
29         } else if (sself.username && sself.password) {
30             operation.credential = [NSURLCredential credentialWithUser:sself.username password:sself.password persistence:NSURLCredentialPersistenceForSession];
31         }
32
33         if (options & SDWebImageDownloaderHighPriority) {
34             operation.queuePriority = NSOperationQueuePriorityHigh;
35         } else if (options & SDWebImageDownloaderLowPriority) {
36             operation.queuePriority = NSOperationQueuePriorityLow;
37         }
38
39         [sself.downloadQueue addOperation:operation];
40         if (sself.executionOrder == SDWebImageDownloaderLIFOExecutionOrder) {
41             // Emulate LIFO execution order by systematically adding new operations as last operation's dependency
42             [sself.lastAddedOperation addDependency:operation];
43             sself.lastAddedOperation = operation;
44         }
45
46         return operation;
47     }];
48 }

1 - (void)cancel:(nullable SDWebImageDownloadToken *)token {
2     dispatch_barrier_async(self.barrierQueue, ^{
3         SDWebImageDownloaderOperation *operation = self.URLOperations[token.url];
4         BOOL canceled = [operation cancel:token.downloadOperationCancelToken];
5         if (canceled) {
6             [self.URLOperations removeObjectForKey:token.url];
7         }
8     });
9 }

1 - (void)setSuspended:(BOOL)suspended {
2     (self.downloadQueue).suspended = suspended;
3 }

1 - (void)cancelAllDownloads {
2     [self.downloadQueue cancelAllOperations];
3 }

 1 #pragma mark Helper methods
 2
 3 - (SDWebImageDownloaderOperation *)operationWithTask:(NSURLSessionTask *)task {
 4     SDWebImageDownloaderOperation *returnOperation = nil;
 5     for (SDWebImageDownloaderOperation *operation in self.downloadQueue.operations) {
 6         if (operation.dataTask.taskIdentifier == task.taskIdentifier) {
 7             returnOperation = operation;
 8             break;
 9         }
10     }
11     return returnOperation;
12 }

 1 - (void)URLSession:(NSURLSession *)session
 2           dataTask:(NSURLSessionDataTask *)dataTask
 3 didReceiveResponse:(NSURLResponse *)response
 4  completionHandler:(void (^)(NSURLSessionResponseDisposition disposition))completionHandler {
 5
 6     // Identify the operation that runs this task and pass it the delegate method
 7     SDWebImageDownloaderOperation *dataOperation = [self operationWithTask:dataTask];
 8
 9     [dataOperation URLSession:session dataTask:dataTask didReceiveResponse:response completionHandler:completionHandler];
10 }
11
12 - (void)URLSession:(NSURLSession *)session dataTask:(NSURLSessionDataTask *)dataTask didReceiveData:(NSData *)data {
13
14     // Identify the operation that runs this task and pass it the delegate method
15     SDWebImageDownloaderOperation *dataOperation = [self operationWithTask:dataTask];
16
17     [dataOperation URLSession:session dataTask:dataTask didReceiveData:data];
18 }
19
20 - (void)URLSession:(NSURLSession *)session
21           dataTask:(NSURLSessionDataTask *)dataTask
22  willCacheResponse:(NSCachedURLResponse *)proposedResponse
23  completionHandler:(void (^)(NSCachedURLResponse *cachedResponse))completionHandler {
24
25     // Identify the operation that runs this task and pass it the delegate method
26     SDWebImageDownloaderOperation *dataOperation = [self operationWithTask:dataTask];
27
28     [dataOperation URLSession:session dataTask:dataTask willCacheResponse:proposedResponse completionHandler:completionHandler];
29 }

 1 - (void)URLSession:(NSURLSession *)session task:(NSURLSessionTask *)task didCompleteWithError:(NSError *)error {
 2     // Identify the operation that runs this task and pass it the delegate method
 3     SDWebImageDownloaderOperation *dataOperation = [self operationWithTask:task];
 4
 5     [dataOperation URLSession:session task:task didCompleteWithError:error];
 6 }
 7
 8 - (void)URLSession:(NSURLSession *)session task:(NSURLSessionTask *)task willPerformHTTPRedirection:(NSHTTPURLResponse *)response newRequest:(NSURLRequest *)request completionHandler:(void (^)(NSURLRequest * _Nullable))completionHandler {
 9
10     completionHandler(request);
11 }
12
13 - (void)URLSession:(NSURLSession *)session task:(NSURLSessionTask *)task didReceiveChallenge:(NSURLAuthenticationChallenge *)challenge completionHandler:(void (^)(NSURLSessionAuthChallengeDisposition disposition, NSURLCredential *credential))completionHandler {
14
15     // Identify the operation that runs this task and pass it the delegate method
16     SDWebImageDownloaderOperation *dataOperation = [self operationWithTask:task];
17
18     [dataOperation URLSession:session task:task didReceiveChallenge:challenge completionHandler:completionHandler];
19 }