@momo-kits/native-kits 0.0.1-beta.5 → 0.89.1-2

package/example/ios/Pods/SDWebImage/SDWebImage/Core/SDWebImageDownloaderOperation.m

@@ -1,722 +0,0 @@
-/*
- * 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 "SDWebImageDownloaderOperation.h"
-#import "SDWebImageError.h"
-#import "SDInternalMacros.h"
-#import "SDWebImageDownloaderResponseModifier.h"
-#import "SDWebImageDownloaderDecryptor.h"
-#import "SDImageCacheDefine.h"
-
-// A handler to represent individual request
-@interface SDWebImageDownloaderOperationToken : NSObject
-
-@property (nonatomic, copy, nullable) SDWebImageDownloaderCompletedBlock completedBlock;
-@property (nonatomic, copy, nullable) SDWebImageDownloaderProgressBlock progressBlock;
-@property (nonatomic, copy, nullable) SDImageCoderOptions *decodeOptions;
-
-@end
-
-@implementation SDWebImageDownloaderOperationToken
-
-- (BOOL)isEqual:(id)other {
-    if (nil == other) {
-      return NO;
-    }
-    if (self == other) {
-      return YES;
-    }
-    if (![other isKindOfClass:[self class]]) {
-      return NO;
-    }
-    SDWebImageDownloaderOperationToken *object = (SDWebImageDownloaderOperationToken *)other;
-    // warn: only compare decodeOptions, ignore pointer, use `removeObjectIdenticalTo`
-    BOOL result = [self.decodeOptions isEqualToDictionary:object.decodeOptions];
-    return result;
-}
-
-@end
-
-@interface SDWebImageDownloaderOperation ()
-
-@property (strong, nonatomic, nonnull) NSMutableArray<SDWebImageDownloaderOperationToken *> *callbackTokens;
-
-@property (assign, nonatomic, readwrite) SDWebImageDownloaderOptions options;
-@property (copy, nonatomic, readwrite, nullable) SDWebImageContext *context;
-
-@property (assign, nonatomic, getter = isExecuting) BOOL executing;
-@property (assign, nonatomic, getter = isFinished) BOOL finished;
-@property (strong, nonatomic, nullable) NSMutableData *imageData;
-@property (copy, nonatomic, nullable) NSData *cachedData; // for `SDWebImageDownloaderIgnoreCachedResponse`
-@property (assign, nonatomic) NSUInteger expectedSize; // may be 0
-@property (assign, nonatomic) NSUInteger receivedSize;
-@property (strong, nonatomic, nullable, readwrite) NSURLResponse *response;
-@property (strong, nonatomic, nullable) NSError *responseError;
-@property (assign, nonatomic) double previousProgress; // previous progress percent
-
-@property (strong, nonatomic, nullable) id<SDWebImageDownloaderResponseModifier> responseModifier; // modify original URLResponse
-@property (strong, nonatomic, nullable) id<SDWebImageDownloaderDecryptor> decryptor; // decrypt image data
-
-// This is weak because it is injected by whoever manages this session. If this gets nil-ed out, we won't be able to run
-// the task associated with this operation
-@property (weak, nonatomic, nullable) NSURLSession *unownedSession;
-// This is set if we're using not using an injected NSURLSession. We're responsible of invalidating this one
-@property (strong, nonatomic, nullable) NSURLSession *ownedSession;
-
-@property (strong, nonatomic, readwrite, nullable) NSURLSessionTask *dataTask;
-
-@property (strong, nonatomic, readwrite, nullable) NSURLSessionTaskMetrics *metrics API_AVAILABLE(macosx(10.12), ios(10.0), watchos(3.0), tvos(10.0));
-
-@property (strong, nonatomic, nonnull) NSOperationQueue *coderQueue; // the serial operation queue to do image decoding
-
-@property (strong, nonatomic, nonnull) NSMapTable<SDImageCoderOptions *, UIImage *> *imageMap; // each variant of image is weak-referenced to avoid too many re-decode during downloading
-#if SD_UIKIT
-@property (assign, nonatomic) UIBackgroundTaskIdentifier backgroundTaskId;
-#endif
-
-@end
-
-@implementation SDWebImageDownloaderOperation
-
-@synthesize executing = _executing;
-@synthesize finished = _finished;
-
-- (nonnull instancetype)init {
-    return [self initWithRequest:nil inSession:nil options:0];
-}
-
-- (instancetype)initWithRequest:(NSURLRequest *)request inSession:(NSURLSession *)session options:(SDWebImageDownloaderOptions)options {
-    return [self initWithRequest:request inSession:session options:options context:nil];
-}
-
-- (nonnull instancetype)initWithRequest:(nullable NSURLRequest *)request
-                              inSession:(nullable NSURLSession *)session
-                                options:(SDWebImageDownloaderOptions)options
-                                context:(nullable SDWebImageContext *)context {
-    if ((self = [super init])) {
-        _request = [request copy];
-        _options = options;
-        _context = [context copy];
-        _callbackTokens = [NSMutableArray new];
-        _responseModifier = context[SDWebImageContextDownloadResponseModifier];
-        _decryptor = context[SDWebImageContextDownloadDecryptor];
-        _executing = NO;
-        _finished = NO;
-        _expectedSize = 0;
-        _unownedSession = session;
-        _coderQueue = [NSOperationQueue new];
-        _coderQueue.maxConcurrentOperationCount = 1;
-        _imageMap = [[NSMapTable alloc] initWithKeyOptions:NSPointerFunctionsStrongMemory valueOptions:NSPointerFunctionsWeakMemory capacity:1];
-#if SD_UIKIT
-        _backgroundTaskId = UIBackgroundTaskInvalid;
-#endif
-    }
-    return self;
-}
-
-- (nullable id)addHandlersForProgress:(nullable SDWebImageDownloaderProgressBlock)progressBlock
-                            completed:(nullable SDWebImageDownloaderCompletedBlock)completedBlock {
-    return [self addHandlersForProgress:progressBlock completed:completedBlock decodeOptions:nil];
-}
-
-- (nullable id)addHandlersForProgress:(nullable SDWebImageDownloaderProgressBlock)progressBlock
-                            completed:(nullable SDWebImageDownloaderCompletedBlock)completedBlock
-                        decodeOptions:(nullable SDImageCoderOptions *)decodeOptions {
-    if (!completedBlock && !progressBlock && !decodeOptions) return nil;
-    SDWebImageDownloaderOperationToken *token = [SDWebImageDownloaderOperationToken new];
-    token.completedBlock = completedBlock;
-    token.progressBlock = progressBlock;
-    token.decodeOptions = decodeOptions;
-    @synchronized (self) {
-        [self.callbackTokens addObject:token];
-    }
-    
-    return token;
-}
-
-- (BOOL)cancel:(nullable id)token {
-    if (![token isKindOfClass:SDWebImageDownloaderOperationToken.class]) return NO;
-    
-    BOOL shouldCancel = NO;
-    @synchronized (self) {
-        NSArray *tokens = self.callbackTokens;
-        if (tokens.count == 1 && [tokens indexOfObjectIdenticalTo:token] != NSNotFound) {
-            shouldCancel = YES;
-        }
-    }
-    if (shouldCancel) {
-        // Cancel operation running and callback last token's completion block
-        [self cancel];
-    } else {
-        // Only callback this token's completion block
-        @synchronized (self) {
-            [self.callbackTokens removeObjectIdenticalTo:token];
-        }
-        SDWebImageDownloaderCompletedBlock completedBlock = ((SDWebImageDownloaderOperationToken *)token).completedBlock;
-        if (completedBlock) {
-            dispatch_main_async_safe(^{
-                completedBlock(nil, nil, [NSError errorWithDomain:SDWebImageErrorDomain code:SDWebImageErrorCancelled userInfo:@{NSLocalizedDescriptionKey : @"Operation cancelled by user during sending the request"}], YES);
-            });
-        }
-    }
-    return shouldCancel;
-}
-
-- (void)start {
-    @synchronized (self) {
-        if (self.isCancelled) {
-            if (!self.isFinished) self.finished = YES;
-            // Operation cancelled by user before sending the request
-            [self callCompletionBlocksWithError:[NSError errorWithDomain:SDWebImageErrorDomain code:SDWebImageErrorCancelled userInfo:@{NSLocalizedDescriptionKey : @"Operation cancelled by user before sending the request"}]];
-            [self reset];
-            return;
-        }
-
-#if SD_UIKIT
-        Class UIApplicationClass = NSClassFromString(@"UIApplication");
-        BOOL hasApplication = UIApplicationClass && [UIApplicationClass respondsToSelector:@selector(sharedApplication)];
-        if (hasApplication && [self shouldContinueWhenAppEntersBackground]) {
-            __weak typeof(self) wself = self;
-            UIApplication * app = [UIApplicationClass performSelector:@selector(sharedApplication)];
-            self.backgroundTaskId = [app beginBackgroundTaskWithExpirationHandler:^{
-                [wself cancel];
-            }];
-        }
-#endif
-        NSURLSession *session = self.unownedSession;
-        if (!session) {
-            NSURLSessionConfiguration *sessionConfig = [NSURLSessionConfiguration defaultSessionConfiguration];
-            sessionConfig.timeoutIntervalForRequest = 15;
-            
-            /**
-             *  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.
-             */
-            session = [NSURLSession sessionWithConfiguration:sessionConfig
-                                                    delegate:self
-                                               delegateQueue:nil];
-            self.ownedSession = session;
-        }
-        
-        if (self.options & SDWebImageDownloaderIgnoreCachedResponse) {
-            // Grab the cached data for later check
-            NSURLCache *URLCache = session.configuration.URLCache;
-            if (!URLCache) {
-                URLCache = [NSURLCache sharedURLCache];
-            }
-            NSCachedURLResponse *cachedResponse;
-            // NSURLCache's `cachedResponseForRequest:` is not thread-safe, see https://developer.apple.com/documentation/foundation/nsurlcache#2317483
-            @synchronized (URLCache) {
-                cachedResponse = [URLCache cachedResponseForRequest:self.request];
-            }
-            if (cachedResponse) {
-                self.cachedData = cachedResponse.data;
-                self.response = cachedResponse.response;
-            }
-        }
-        
-        if (!session.delegate) {
-            // Session been invalid and has no delegate at all
-            [self callCompletionBlocksWithError:[NSError errorWithDomain:SDWebImageErrorDomain code:SDWebImageErrorInvalidDownloadOperation userInfo:@{NSLocalizedDescriptionKey : @"Session delegate is nil and invalid"}]];
-            [self reset];
-            return;
-        }
-        
-        self.dataTask = [session dataTaskWithRequest:self.request];
-        self.executing = YES;
-    }
-
-    if (self.dataTask) {
-        if (self.options & SDWebImageDownloaderHighPriority) {
-            self.dataTask.priority = NSURLSessionTaskPriorityHigh;
-            self.coderQueue.qualityOfService = NSQualityOfServiceUserInteractive;
-        } else if (self.options & SDWebImageDownloaderLowPriority) {
-            self.dataTask.priority = NSURLSessionTaskPriorityLow;
-            self.coderQueue.qualityOfService = NSQualityOfServiceBackground;
-        } else {
-            self.dataTask.priority = NSURLSessionTaskPriorityDefault;
-            self.coderQueue.qualityOfService = NSQualityOfServiceDefault;
-        }
-        [self.dataTask resume];
-        NSArray<SDWebImageDownloaderOperationToken *> *tokens;
-        @synchronized (self) {
-            tokens = [self.callbackTokens copy];
-        }
-        for (SDWebImageDownloaderOperationToken *token in tokens) {
-            if (token.progressBlock) {
-                token.progressBlock(0, NSURLResponseUnknownLength, self.request.URL);
-            }
-        }
-        __block typeof(self) strongSelf = self;
-        dispatch_async(dispatch_get_main_queue(), ^{
-            [[NSNotificationCenter defaultCenter] postNotificationName:SDWebImageDownloadStartNotification object:strongSelf];
-        });
-    } else {
-        if (!self.isFinished) self.finished = YES;
-        [self callCompletionBlocksWithError:[NSError errorWithDomain:SDWebImageErrorDomain code:SDWebImageErrorInvalidDownloadOperation userInfo:@{NSLocalizedDescriptionKey : @"Task can't be initialized"}]];
-        [self reset];
-    }
-}
-
-- (void)cancel {
-    @synchronized (self) {
-        [self cancelInternal];
-    }
-}
-
-- (void)cancelInternal {
-    if (self.isFinished) return;
-    [super cancel];
-    
-    __block typeof(self) strongSelf = self;
-    dispatch_async(dispatch_get_main_queue(), ^{
-        [[NSNotificationCenter defaultCenter] postNotificationName:SDWebImageDownloadStopNotification object:strongSelf];
-    });
-
-    if (self.dataTask) {
-        // Cancel the URLSession, `URLSession:task:didCompleteWithError:` delegate callback will be ignored
-        [self.dataTask cancel];
-        self.dataTask = nil;
-    }
-    
-    // NSOperation disallow setFinished=YES **before** operation's start method been called
-    // We check for the initialized status, which is isExecuting == NO && isFinished = NO
-    // Ony update for non-intialized status, which is !(isExecuting == NO && isFinished = NO), or if (self.isExecuting || self.isFinished) {...}
-    if (self.isExecuting || self.isFinished) {
-        if (self.isExecuting) self.executing = NO;
-        if (!self.isFinished) self.finished = YES;
-    }
-    
-    // Operation cancelled by user during sending the request
-    [self callCompletionBlocksWithError:[NSError errorWithDomain:SDWebImageErrorDomain code:SDWebImageErrorCancelled userInfo:@{NSLocalizedDescriptionKey : @"Operation cancelled by user during sending the request"}]];
-
-    [self reset];
-}
-
-- (void)done {
-    self.finished = YES;
-    self.executing = NO;
-    [self reset];
-}
-
-- (void)reset {
-    @synchronized (self) {
-        [self.callbackTokens removeAllObjects];
-        self.dataTask = nil;
-        
-        if (self.ownedSession) {
-            [self.ownedSession invalidateAndCancel];
-            self.ownedSession = nil;
-        }
-        
-#if SD_UIKIT
-        if (self.backgroundTaskId != UIBackgroundTaskInvalid) {
-            // If backgroundTaskId != UIBackgroundTaskInvalid, sharedApplication is always exist
-            UIApplication * app = [UIApplication performSelector:@selector(sharedApplication)];
-            [app endBackgroundTask:self.backgroundTaskId];
-            self.backgroundTaskId = UIBackgroundTaskInvalid;
-        }
-#endif
-    }
-}
-
-- (void)setFinished:(BOOL)finished {
-    [self willChangeValueForKey:@"isFinished"];
-    _finished = finished;
-    [self didChangeValueForKey:@"isFinished"];
-}
-
-- (void)setExecuting:(BOOL)executing {
-    [self willChangeValueForKey:@"isExecuting"];
-    _executing = executing;
-    [self didChangeValueForKey:@"isExecuting"];
-}
-
-- (BOOL)isConcurrent {
-    return YES;
-}
-
-#pragma mark NSURLSessionDataDelegate
-
-- (void)URLSession:(NSURLSession *)session
-          dataTask:(NSURLSessionDataTask *)dataTask
-didReceiveResponse:(NSURLResponse *)response
- completionHandler:(void (^)(NSURLSessionResponseDisposition disposition))completionHandler {
-    NSURLSessionResponseDisposition disposition = NSURLSessionResponseAllow;
-    
-    // Check response modifier, if return nil, will marked as cancelled.
-    BOOL valid = YES;
-    if (self.responseModifier && response) {
-        response = [self.responseModifier modifiedResponseWithResponse:response];
-        if (!response) {
-            valid = NO;
-            self.responseError = [NSError errorWithDomain:SDWebImageErrorDomain
-                                                     code:SDWebImageErrorInvalidDownloadResponse
-                                                 userInfo:@{NSLocalizedDescriptionKey : @"Download marked as failed because response is nil"}];
-        }
-    }
-    
-    NSInteger expected = (NSInteger)response.expectedContentLength;
-    expected = expected > 0 ? expected : 0;
-    self.expectedSize = expected;
-    self.response = response;
-    
-    // Check status code valid (defaults [200,400))
-    NSInteger statusCode = [response isKindOfClass:NSHTTPURLResponse.class] ? ((NSHTTPURLResponse *)response).statusCode : 0;
-    BOOL statusCodeValid = YES;
-    if (valid && statusCode > 0 && self.acceptableStatusCodes) {
-        statusCodeValid = [self.acceptableStatusCodes containsIndex:statusCode];
-    }
-    if (!statusCodeValid) {
-        valid = NO;
-        self.responseError = [NSError errorWithDomain:SDWebImageErrorDomain
-                                                 code:SDWebImageErrorInvalidDownloadStatusCode
-                                             userInfo:@{NSLocalizedDescriptionKey : [NSString stringWithFormat:@"Download marked as failed because of invalid response status code %ld", (long)statusCode],
-                                                        SDWebImageErrorDownloadStatusCodeKey : @(statusCode),
-                                                        SDWebImageErrorDownloadResponseKey : response}];
-    }
-    // Check content type valid (defaults nil)
-    NSString *contentType = [response isKindOfClass:NSHTTPURLResponse.class] ? ((NSHTTPURLResponse *)response).MIMEType : nil;
-    BOOL contentTypeValid = YES;
-    if (valid && contentType.length > 0 && self.acceptableContentTypes) {
-        contentTypeValid = [self.acceptableContentTypes containsObject:contentType];
-    }
-    if (!contentTypeValid) {
-        valid = NO;
-        self.responseError = [NSError errorWithDomain:SDWebImageErrorDomain
-                                                 code:SDWebImageErrorInvalidDownloadContentType
-                                             userInfo:@{NSLocalizedDescriptionKey : [NSString stringWithFormat:@"Download marked as failed because of invalid response content type %@", contentType],
-                                                        SDWebImageErrorDownloadContentTypeKey : contentType,
-                                                        SDWebImageErrorDownloadResponseKey : response}];
-    }
-    //'304 Not Modified' is an exceptional one
-    //URLSession current behavior will return 200 status code when the server respond 304 and URLCache hit. But this is not a standard behavior and we just add a check
-    if (valid && statusCode == 304 && !self.cachedData) {
-        valid = NO;
-        self.responseError = [NSError errorWithDomain:SDWebImageErrorDomain
-                                                 code:SDWebImageErrorCacheNotModified
-                                             userInfo:@{NSLocalizedDescriptionKey: @"Download response status code is 304 not modified and ignored",
-                                                        SDWebImageErrorDownloadResponseKey : response}];
-    }
-    
-    if (valid) {
-        NSArray<SDWebImageDownloaderOperationToken *> *tokens;
-        @synchronized (self) {
-            tokens = [self.callbackTokens copy];
-        }
-        for (SDWebImageDownloaderOperationToken *token in tokens) {
-            if (token.progressBlock) {
-                token.progressBlock(0, expected, self.request.URL);
-            }
-        }
-    } else {
-        // Status code invalid and marked as cancelled. Do not call `[self.dataTask cancel]` which may mass up URLSession life cycle
-        disposition = NSURLSessionResponseCancel;
-    }
-    __block typeof(self) strongSelf = self;
-    dispatch_async(dispatch_get_main_queue(), ^{
-        [[NSNotificationCenter defaultCenter] postNotificationName:SDWebImageDownloadReceiveResponseNotification object:strongSelf];
-    });
-    
-    if (completionHandler) {
-        completionHandler(disposition);
-    }
-}
-
-- (void)URLSession:(NSURLSession *)session dataTask:(NSURLSessionDataTask *)dataTask didReceiveData:(NSData *)data {
-    if (!self.imageData) {
-        self.imageData = [[NSMutableData alloc] initWithCapacity:self.expectedSize];
-    }
-    [self.imageData appendData:data];
-    
-    self.receivedSize = self.imageData.length;
-    NSArray<SDWebImageDownloaderOperationToken *> *tokens;
-    @synchronized (self) {
-        tokens = [self.callbackTokens copy];
-    }
-    if (self.expectedSize == 0) {
-        // Unknown expectedSize, immediately call progressBlock and return
-        for (SDWebImageDownloaderOperationToken *token in tokens) {
-            if (token.progressBlock) {
-                token.progressBlock(self.receivedSize, self.expectedSize, self.request.URL);
-            }
-        }
-        return;
-    }
-    
-    // Get the finish status
-    BOOL finished = (self.receivedSize >= self.expectedSize);
-    // Get the current progress
-    double currentProgress = (double)self.receivedSize / (double)self.expectedSize;
-    double previousProgress = self.previousProgress;
-    double progressInterval = currentProgress - previousProgress;
-    // Check if we need callback progress
-    if (!finished && (progressInterval < self.minimumProgressInterval)) {
-        return;
-    }
-    self.previousProgress = currentProgress;
-    
-    // Using data decryptor will disable the progressive decoding, since there are no support for progressive decrypt
-    BOOL supportProgressive = (self.options & SDWebImageDownloaderProgressiveLoad) && !self.decryptor;
-    // When multiple thumbnail decoding use different size, this progressive decoding will cause issue because each callback assume called with different size's image, can not share the same decoding part
-    // We currently only pick the first thumbnail size, see #3423 talks
-    // Progressive decoding Only decode partial image, full image in `URLSession:task:didCompleteWithError:`
-    if (supportProgressive && !finished) {
-        // Get the image data
-        NSData *imageData = self.imageData;
-        
-        // keep maximum one progressive decode process during download
-        if (self.coderQueue.operationCount == 0) {
-            // NSOperation have autoreleasepool, don't need to create extra one
-            @weakify(self);
-            NSOperation *operation = [NSBlockOperation blockOperationWithBlock:^{
-                @strongify(self);
-                if (!self) {
-                    return;
-                }
-                UIImage *image = SDImageLoaderDecodeProgressiveImageData(imageData, self.request.URL, NO, self, [[self class] imageOptionsFromDownloaderOptions:self.options], self.context);
-                if (self.isFinished) {
-                    return;
-                }
-                if (image) {
-                    // We do not keep the progressive decoding image even when `finished`=YES. Because they are for view rendering but not take full function from downloader options. And some coders implementation may not keep consistent between progressive decoding and normal decoding.
-                    
-                    [self callCompletionBlocksWithImage:image imageData:nil error:nil finished:NO];
-                }
-            }];
-            [self.coderQueue addOperation:operation];
-        }
-    }
-    
-    for (SDWebImageDownloaderOperationToken *token in tokens) {
-        if (token.progressBlock) {
-            token.progressBlock(self.receivedSize, self.expectedSize, self.request.URL);
-        }
-    }
-}
-
-- (void)URLSession:(NSURLSession *)session
-          dataTask:(NSURLSessionDataTask *)dataTask
- willCacheResponse:(NSCachedURLResponse *)proposedResponse
- completionHandler:(void (^)(NSCachedURLResponse *cachedResponse))completionHandler {
-    
-    NSCachedURLResponse *cachedResponse = proposedResponse;
-
-    if (!(self.options & SDWebImageDownloaderUseNSURLCache)) {
-        // Prevents caching of responses
-        cachedResponse = nil;
-    }
-    if (completionHandler) {
-        completionHandler(cachedResponse);
-    }
-}
-
-#pragma mark NSURLSessionTaskDelegate
-
-- (void)URLSession:(NSURLSession *)session task:(NSURLSessionTask *)task didCompleteWithError:(NSError *)error {
-    // If we already cancel the operation or anything mark the operation finished, don't callback twice
-    if (self.isFinished) return;
-    
-    NSArray<SDWebImageDownloaderOperationToken *> *tokens;
-    @synchronized (self) {
-        tokens = [self.callbackTokens copy];
-        self.dataTask = nil;
-        __block typeof(self) strongSelf = self;
-        dispatch_async(dispatch_get_main_queue(), ^{
-            [[NSNotificationCenter defaultCenter] postNotificationName:SDWebImageDownloadStopNotification object:strongSelf];
-            if (!error) {
-                [[NSNotificationCenter defaultCenter] postNotificationName:SDWebImageDownloadFinishNotification object:strongSelf];
-            }
-        });
-    }
-    
-    // make sure to call `[self done]` to mark operation as finished
-    if (error) {
-        // custom error instead of URLSession error
-        if (self.responseError) {
-            error = self.responseError;
-        }
-        [self callCompletionBlocksWithError:error];
-        [self done];
-    } else {
-        if (tokens.count > 0) {
-            NSData *imageData = self.imageData;
-            self.imageData = nil;
-            // data decryptor
-            if (imageData && self.decryptor) {
-                imageData = [self.decryptor decryptedDataWithData:imageData response:self.response];
-            }
-            if (imageData) {
-                /**  if you specified to only use cached data via `SDWebImageDownloaderIgnoreCachedResponse`,
-                 *  then we should check if the cached data is equal to image data
-                 */
-                if (self.options & SDWebImageDownloaderIgnoreCachedResponse && [self.cachedData isEqualToData:imageData]) {
-                    self.responseError = [NSError errorWithDomain:SDWebImageErrorDomain
-                                                             code:SDWebImageErrorCacheNotModified
-                                                         userInfo:@{NSLocalizedDescriptionKey : @"Downloaded image is not modified and ignored",
-                                                                    SDWebImageErrorDownloadResponseKey : self.response}];
-                    // call completion block with not modified error
-                    [self callCompletionBlocksWithError:self.responseError];
-                    [self done];
-                } else {
-                    // decode the image in coder queue, cancel all previous decoding process
-                    [self.coderQueue cancelAllOperations];
-                    @weakify(self);
-                    // call done after all different variant completed block was dispatched
-                    NSOperation *doneOperation = [NSBlockOperation blockOperationWithBlock:^{
-                        @strongify(self);
-                        if (!self) {
-                            return;
-                        }
-                        [self done];
-                    }];
-                    for (SDWebImageDownloaderOperationToken *token in tokens) {
-                        NSOperation *operation = [NSBlockOperation blockOperationWithBlock:^{
-                            @strongify(self);
-                            if (!self) {
-                                return;
-                            }
-                            UIImage *image;
-                            // check if we already decode this variant of image for current callback
-                            if (token.decodeOptions) {
-                                image = [self.imageMap objectForKey:token.decodeOptions];
-                            }
-                            if (!image) {
-                                // check if we already use progressive decoding, use that to produce faster decoding
-                                id<SDProgressiveImageCoder> progressiveCoder = SDImageLoaderGetProgressiveCoder(self);
-                                SDWebImageOptions options = [[self class] imageOptionsFromDownloaderOptions:self.options];
-                                SDWebImageContext *context;
-                                if (token.decodeOptions) {
-                                    SDWebImageMutableContext *mutableContext = [NSMutableDictionary dictionaryWithDictionary:self.context];
-                                    SDSetDecodeOptionsToContext(mutableContext, &options, token.decodeOptions);
-                                    context = [mutableContext copy];
-                                } else {
-                                    context = self.context;
-                                }
-                                if (progressiveCoder) {
-                                    image = SDImageLoaderDecodeProgressiveImageData(imageData, self.request.URL, YES, self, options, context);
-                                } else {
-                                    image = SDImageLoaderDecodeImageData(imageData, self.request.URL, options, context);
-                                }
-                                if (image && token.decodeOptions) {
-                                    [self.imageMap setObject:image forKey:token.decodeOptions];
-                                }
-                            }
-                            CGSize imageSize = image.size;
-                            if (imageSize.width == 0 || imageSize.height == 0) {
-                                NSString *description = image == nil ? @"Downloaded image decode failed" : @"Downloaded image has 0 pixels";
-                                [self callCompletionBlocksWithError:[NSError errorWithDomain:SDWebImageErrorDomain code:SDWebImageErrorBadImageData userInfo:@{NSLocalizedDescriptionKey : description}]];
-                            } else {
-                                [self callCompletionBlockWithToken:token image:image imageData:imageData error:nil finished:YES];
-                            }
-                        }];
-                        [doneOperation addDependency:operation];
-                        [self.coderQueue addOperation:operation];
-                    }
-                    // call [self done] after all completed block was dispatched
-                    [self.coderQueue addOperation:doneOperation];
-                }
-            } else {
-                [self callCompletionBlocksWithError:[NSError errorWithDomain:SDWebImageErrorDomain code:SDWebImageErrorBadImageData userInfo:@{NSLocalizedDescriptionKey : @"Image data is nil"}]];
-                [self done];
-            }
-        } else {
-            [self done];
-        }
-    }
-}
-
-- (void)URLSession:(NSURLSession *)session task:(NSURLSessionTask *)task didReceiveChallenge:(NSURLAuthenticationChallenge *)challenge completionHandler:(void (^)(NSURLSessionAuthChallengeDisposition disposition, NSURLCredential *credential))completionHandler {
-    
-    NSURLSessionAuthChallengeDisposition disposition = NSURLSessionAuthChallengePerformDefaultHandling;
-    __block NSURLCredential *credential = nil;
-    
-    if ([challenge.protectionSpace.authenticationMethod isEqualToString:NSURLAuthenticationMethodServerTrust]) {
-        if (!(self.options & SDWebImageDownloaderAllowInvalidSSLCertificates)) {
-            disposition = NSURLSessionAuthChallengePerformDefaultHandling;
-        } else {
-            credential = [NSURLCredential credentialForTrust:challenge.protectionSpace.serverTrust];
-            disposition = NSURLSessionAuthChallengeUseCredential;
-        }
-    } else {
-        if (challenge.previousFailureCount == 0) {
-            if (self.credential) {
-                credential = self.credential;
-                disposition = NSURLSessionAuthChallengeUseCredential;
-            } else {
-                // Web Server like Nginx can set `ssl_verify_client` to optional but not always on
-                // We'd better use default handling here
-                disposition = NSURLSessionAuthChallengePerformDefaultHandling;
-            }
-        } else {
-            disposition = NSURLSessionAuthChallengeCancelAuthenticationChallenge;
-        }
-    }
-    
-    if (completionHandler) {
-        completionHandler(disposition, credential);
-    }
-}
-
-- (void)URLSession:(NSURLSession *)session task:(NSURLSessionTask *)task didFinishCollectingMetrics:(NSURLSessionTaskMetrics *)metrics API_AVAILABLE(macosx(10.12), ios(10.0), watchos(3.0), tvos(10.0)) {
-    self.metrics = metrics;
-}
-
-#pragma mark Helper methods
-+ (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;
-}
-
-- (BOOL)shouldContinueWhenAppEntersBackground {
-    return SD_OPTIONS_CONTAINS(self.options, SDWebImageDownloaderContinueInBackground);
-}
-
-- (void)callCompletionBlocksWithError:(nullable NSError *)error {
-    [self callCompletionBlocksWithImage:nil imageData:nil error:error finished:YES];
-}
-
-- (void)callCompletionBlocksWithImage:(nullable UIImage *)image
-                           imageData:(nullable NSData *)imageData
-                               error:(nullable NSError *)error
-                            finished:(BOOL)finished {
-    NSArray<SDWebImageDownloaderOperationToken *> *tokens;
-    @synchronized (self) {
-        tokens = [self.callbackTokens copy];
-    }
-    for (SDWebImageDownloaderOperationToken *token in tokens) {
-        SDWebImageDownloaderCompletedBlock completedBlock = token.completedBlock;
-        if (completedBlock) {
-            dispatch_main_async_safe(^{
-                completedBlock(image, imageData, error, finished);
-            });
-        }
-    }
-}
-
-- (void)callCompletionBlockWithToken:(nonnull SDWebImageDownloaderOperationToken *)token
-                               image:(nullable UIImage *)image
-                           imageData:(nullable NSData *)imageData
-                               error:(nullable NSError *)error
-                            finished:(BOOL)finished {
-    SDWebImageDownloaderCompletedBlock completedBlock = token.completedBlock;
-    if (completedBlock) {
-        dispatch_main_async_safe(^{
-            completedBlock(image, imageData, error, finished);
-        });
-    }
-}
-
-@end