Merge branch '4.x' into gif

# Conflicts:
#	SDWebImage/MKAnnotationView+WebCache.h
#	SDWebImage/MKAnnotationView+WebCache.m
#	SDWebImage/SDImageCache.h
#	SDWebImage/SDImageCache.m
#	SDWebImage/SDWebImageManager.h
#	SDWebImage/SDWebImageManager.m
#	SDWebImage/UIButton+WebCache.h
#	SDWebImage/UIButton+WebCache.m
#	SDWebImage/UIImageView+HighlightedWebCache.h
#	SDWebImage/UIImageView+HighlightedWebCache.m
#	SDWebImage/UIImageView+WebCache.h
#	SDWebImage/UIImageView+WebCache.m

+## [3.8.1 Patch release for 3.8.0 on Jun 7th, 2016](https://github.com/rs/SDWebImage/releases/tag/3.8.1)
+
+#### Fixes:
+
+- SDWebImage 3.8.0 get wrong image #1589 - the issue was caused by the changes in 3.8.0 (Removed the URL query params from the filename (key) fb0cdb6d 1bf62d4 #1584 - fixes #1433 #1553 #1583 #1585) - Reverted. 
+- Note: The solution for those issues (i.e. #1433 #1553) is to set the `SDWebImageManager` `cacheKeyFilter` block and do their own calculations there.
+
 ## [3.8.0 Minor release - Replaces NSURLConnection (deprecated) with NSURLSession - on Jun 6th, 2016](https://github.com/rs/SDWebImage/releases/tag/3.8.0)
 ## [3.8.0 Minor release - Replaces NSURLConnection (deprecated) with NSURLSession - on Jun 6th, 2016](https://github.com/rs/SDWebImage/releases/tag/3.8.0)
 
 
 #### Infrastructure:
 #### Infrastructure:
@@ -11,7 +18,7 @@
 
 
 #### Fixes:
 #### Fixes:
 
 
-- Removed the URL query params from the filename (key) fb0cdb6d 1bf62d4 #1584 - fixes #1433 #1533 #1583 #1585
+- Removed the URL query params from the filename (key) fb0cdb6d 1bf62d4 #1584 - fixes #1433 #1553 #1583 #1585
 - Fixed the WebP build with the official 1.0.0 CocoaPods release f1a471e - fixes #1444
 - Fixed the WebP build with the official 1.0.0 CocoaPods release f1a471e - fixes #1444
 - Updated doc: `removeImageForKey:` not synchronous e6e5c51 - fixes #1379 #1415
 - Updated doc: `removeImageForKey:` not synchronous e6e5c51 - fixes #1379 #1415
 
 

 Pod::Spec.new do |s|
 Pod::Spec.new do |s|
   s.name = 'SDWebImage'
   s.name = 'SDWebImage'
-  s.version = '3.8.0'
+  s.version = '3.8.1'
   s.ios.deployment_target = '7.0'
   s.ios.deployment_target = '7.0'
   s.tvos.deployment_target = '9.0'
   s.tvos.deployment_target = '9.0'
   s.license = 'MIT'
   s.license = 'MIT'

@@ -1423,6 +1423,7 @@
 			isa = XCBuildConfiguration;
 			isa = XCBuildConfiguration;
 			buildSettings = {
 			buildSettings = {
 				ALWAYS_SEARCH_USER_PATHS = NO;
 				ALWAYS_SEARCH_USER_PATHS = NO;
+				CLANG_ANALYZER_NONNULL = YES;
 				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
 				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
 				CLANG_CXX_LIBRARY = "libc++";
 				CLANG_CXX_LIBRARY = "libc++";
 				CLANG_ENABLE_MODULES = YES;
 				CLANG_ENABLE_MODULES = YES;
@@ -1483,6 +1484,7 @@
 			isa = XCBuildConfiguration;
 			isa = XCBuildConfiguration;
 			buildSettings = {
 			buildSettings = {
 				ALWAYS_SEARCH_USER_PATHS = NO;
 				ALWAYS_SEARCH_USER_PATHS = NO;
+				CLANG_ANALYZER_NONNULL = YES;
 				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
 				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
 				CLANG_CXX_LIBRARY = "libc++";
 				CLANG_CXX_LIBRARY = "libc++";
 				CLANG_ENABLE_MODULES = YES;
 				CLANG_ENABLE_MODULES = YES;

@@ -28,7 +28,7 @@
  * Note that because of the limitations of categories this property can get out of sync
  * Note that because of the limitations of categories this property can get out of sync
  * if you use setImage: directly.
  * if you use setImage: directly.
  */
  */
-- (NSURL *)sd_imageURL;
+- (nullable NSURL *)sd_imageURL;
 
 
 /**
 /**
  * Load the image at the given url (either from cache or download) and load it in this imageView. It works with both static and dynamic images
  * Load the image at the given url (either from cache or download) and load it in this imageView. It works with both static and dynamic images
@@ -36,7 +36,7 @@
  *
  *
  * @param url The url for the image.
  * @param url The url for the image.
  */
  */
-- (void)sd_setImageWithURL:(NSURL *)url;
+- (void)sd_setImageWithURL:(nullable NSURL *)url;
 
 
 /**
 /**
  * Load the image at the given url (either from cache or download) and load it in this imageView. It works with both static and dynamic images
  * Load the image at the given url (either from cache or download) and load it in this imageView. It works with both static and dynamic images
@@ -46,7 +46,8 @@
  * @param url         The url for the image.
  * @param url         The url for the image.
  * @param placeholder The image to be set initially, until the image request finishes.
  * @param placeholder The image to be set initially, until the image request finishes.
  */
  */
-- (void)sd_setImageWithURL:(NSURL *)url placeholderImage:(UIImage *)placeholder;
+- (void)sd_setImageWithURL:(nullable NSURL *)url
+          placeholderImage:(nullable UIImage *)placeholder;
 
 
 /**
 /**
  * Load the image at the given url (either from cache or download) and load it in this imageView. It works with both static and dynamic images
  * Load the image at the given url (either from cache or download) and load it in this imageView. It works with both static and dynamic images
@@ -57,7 +58,9 @@
  *  @param placeholder The image to be set initially, until the image request finishes.
  *  @param placeholder The image to be set initially, until the image request finishes.
  *  @param options     The options to use when downloading the image. @see SDWebImageOptions for the possible values.
  *  @param options     The options to use when downloading the image. @see SDWebImageOptions for the possible values.
  */
  */
-- (void)sd_setImageWithURL:(NSURL *)url placeholderImage:(UIImage *)placeholder options:(SDWebImageOptions)options;
+- (void)sd_setImageWithURL:(nullable NSURL *)url
+          placeholderImage:(nullable UIImage *)placeholder
+                   options:(SDWebImageOptions)options;
 
 
 /**
 /**
  * Load the image at the given url (either from cache or download) and load it in this imageView. It works with both static and dynamic images
  * Load the image at the given url (either from cache or download) and load it in this imageView. It works with both static and dynamic images
@@ -70,7 +73,8 @@
  *                        indicating if the image was retrieved from the local cache or from the network.
  *                        indicating if the image was retrieved from the local cache or from the network.
  *                        The fourth parameter is the original image url.
  *                        The fourth parameter is the original image url.
  */
  */
-- (void)sd_setImageWithURL:(NSURL *)url completed:(SDExternalCompletionBlock)completedBlock;
+- (void)sd_setImageWithURL:(nullable NSURL *)url
+                 completed:(nullable SDExternalCompletionBlock)completedBlock;
 
 
 /**
 /**
  * Load the image at the given url (either from cache or download) and load it in this imageView. It works with both static and dynamic images
  * Load the image at the given url (either from cache or download) and load it in this imageView. It works with both static and dynamic images
@@ -85,7 +89,9 @@
  *                        indicating if the image was retrieved from the local cache or from the network.
  *                        indicating if the image was retrieved from the local cache or from the network.
  *                        The fourth parameter is the original image url.
  *                        The fourth parameter is the original image url.
  */
  */
-- (void)sd_setImageWithURL:(NSURL *)url placeholderImage:(UIImage *)placeholder completed:(SDExternalCompletionBlock)completedBlock;
+- (void)sd_setImageWithURL:(nullable NSURL *)url
+          placeholderImage:(nullable UIImage *)placeholder
+                 completed:(nullable SDExternalCompletionBlock)completedBlock;
 
 
 /**
 /**
  * Load the image at the given url (either from cache or download) and load it in this imageView. It works with both static and dynamic images
  * Load the image at the given url (either from cache or download) and load it in this imageView. It works with both static and dynamic images
@@ -101,7 +107,10 @@
  *                        indicating if the image was retrieved from the local cache or from the network.
  *                        indicating if the image was retrieved from the local cache or from the network.
  *                        The fourth parameter is the original image url.
  *                        The fourth parameter is the original image url.
  */
  */
-- (void)sd_setImageWithURL:(NSURL *)url placeholderImage:(UIImage *)placeholder options:(SDWebImageOptions)options completed:(SDExternalCompletionBlock)completedBlock;
+- (void)sd_setImageWithURL:(nullable NSURL *)url
+          placeholderImage:(nullable UIImage *)placeholder
+                   options:(SDWebImageOptions)options
+                 completed:(nullable SDExternalCompletionBlock)completedBlock;
 
 
 /**
 /**
  * Load the image at the given url (either from cache or download) and load it in this imageView. It works with both static and dynamic images
  * Load the image at the given url (either from cache or download) and load it in this imageView. It works with both static and dynamic images
@@ -118,7 +127,11 @@
  *                        indicating if the image was retrieved from the local cache or from the network.
  *                        indicating if the image was retrieved from the local cache or from the network.
  *                        The fourth parameter is the original image url.
  *                        The fourth parameter is the original image url.
  */
  */
-- (void)sd_setImageWithURL:(NSURL *)url placeholderImage:(UIImage *)placeholder options:(SDWebImageOptions)options progress:(SDWebImageDownloaderProgressBlock)progressBlock completed:(SDExternalCompletionBlock)completedBlock;
+- (void)sd_setImageWithURL:(nullable NSURL *)url
+          placeholderImage:(nullable UIImage *)placeholder
+                   options:(SDWebImageOptions)options
+                  progress:(nullable SDWebImageDownloaderProgressBlock)progressBlock
+                 completed:(nullable SDExternalCompletionBlock)completedBlock;
 
 
 /**
 /**
  * Cancel the image load
  * Cancel the image load

@@ -19,35 +19,39 @@ static char imageURLKey;
 
 
 @implementation FLAnimatedImageView (WebCache)
 @implementation FLAnimatedImageView (WebCache)
 
 
-- (NSURL *)sd_imageURL {
+- (nullable NSURL *)sd_imageURL {
     return objc_getAssociatedObject(self, &imageURLKey);
     return objc_getAssociatedObject(self, &imageURLKey);
 }
 }
 
 
-- (void)sd_setImageWithURL:(NSURL *)url {
+- (void)sd_setImageWithURL:(nullable NSURL *)url {
     [self sd_setImageWithURL:url placeholderImage:nil options:0 progress:nil completed:nil];
     [self sd_setImageWithURL:url placeholderImage:nil options:0 progress:nil completed:nil];
 }
 }
 
 
-- (void)sd_setImageWithURL:(NSURL *)url placeholderImage:(UIImage *)placeholder {
+- (void)sd_setImageWithURL:(nullable NSURL *)url placeholderImage:(nullable UIImage *)placeholder {
     [self sd_setImageWithURL:url placeholderImage:placeholder options:0 progress:nil completed:nil];
     [self sd_setImageWithURL:url placeholderImage:placeholder options:0 progress:nil completed:nil];
 }
 }
 
 
-- (void)sd_setImageWithURL:(NSURL *)url placeholderImage:(UIImage *)placeholder options:(SDWebImageOptions)options {
+- (void)sd_setImageWithURL:(nullable NSURL *)url placeholderImage:(nullable UIImage *)placeholder options:(SDWebImageOptions)options {
     [self sd_setImageWithURL:url placeholderImage:placeholder options:options progress:nil completed:nil];
     [self sd_setImageWithURL:url placeholderImage:placeholder options:options progress:nil completed:nil];
 }
 }
 
 
-- (void)sd_setImageWithURL:(NSURL *)url completed:(SDExternalCompletionBlock)completedBlock {
+- (void)sd_setImageWithURL:(nullable NSURL *)url completed:(nullable SDExternalCompletionBlock)completedBlock {
     [self sd_setImageWithURL:url placeholderImage:nil options:0 progress:nil completed:completedBlock];
     [self sd_setImageWithURL:url placeholderImage:nil options:0 progress:nil completed:completedBlock];
 }
 }
 
 
-- (void)sd_setImageWithURL:(NSURL *)url placeholderImage:(UIImage *)placeholder completed:(SDExternalCompletionBlock)completedBlock {
+- (void)sd_setImageWithURL:(nullable NSURL *)url placeholderImage:(nullable UIImage *)placeholder completed:(nullable SDExternalCompletionBlock)completedBlock {
     [self sd_setImageWithURL:url placeholderImage:placeholder options:0 progress:nil completed:completedBlock];
     [self sd_setImageWithURL:url placeholderImage:placeholder options:0 progress:nil completed:completedBlock];
 }
 }
 
 
-- (void)sd_setImageWithURL:(NSURL *)url placeholderImage:(UIImage *)placeholder options:(SDWebImageOptions)options completed:(SDExternalCompletionBlock)completedBlock {
+- (void)sd_setImageWithURL:(nullable NSURL *)url placeholderImage:(nullable UIImage *)placeholder options:(SDWebImageOptions)options completed:(nullable SDExternalCompletionBlock)completedBlock {
     [self sd_setImageWithURL:url placeholderImage:placeholder options:options progress:nil completed:completedBlock];
     [self sd_setImageWithURL:url placeholderImage:placeholder options:options progress:nil completed:completedBlock];
 }
 }
 
 
-- (void)sd_setImageWithURL:(NSURL *)url placeholderImage:(UIImage *)placeholder options:(SDWebImageOptions)options progress:(SDWebImageDownloaderProgressBlock)progressBlock completed:(SDExternalCompletionBlock)completedBlock {
+- (void)sd_setImageWithURL:(nullable NSURL *)url
+          placeholderImage:(nullable UIImage *)placeholder
+                   options:(SDWebImageOptions)options
+                  progress:(nullable SDWebImageDownloaderProgressBlock)progressBlock
+                 completed:(nullable SDExternalCompletionBlock)completedBlock {
     [self sd_cancelCurrentImageLoad];
     [self sd_cancelCurrentImageLoad];
     objc_setAssociatedObject(self, &imageURLKey, url, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
     objc_setAssociatedObject(self, &imageURLKey, url, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
 
 

@@ -20,7 +20,7 @@
  * Note that because of the limitations of categories this property can get out of sync
  * Note that because of the limitations of categories this property can get out of sync
  * if you use setImage: directly.
  * if you use setImage: directly.
  */
  */
-- (NSURL *)sd_imageURL;
+- (nullable NSURL *)sd_imageURL;
 
 
 /**
 /**
  * Set the imageView `image` with an `url`.
  * Set the imageView `image` with an `url`.
@@ -29,7 +29,7 @@
  *
  *
  * @param url The url for the image.
  * @param url The url for the image.
  */
  */
-- (void)sd_setImageWithURL:(NSURL *)url;
+- (void)sd_setImageWithURL:(nullable NSURL *)url;
 
 
 /**
 /**
  * Set the imageView `image` with an `url` and a placeholder.
  * Set the imageView `image` with an `url` and a placeholder.
@@ -40,7 +40,8 @@
  * @param placeholder The image to be set initially, until the image request finishes.
  * @param placeholder The image to be set initially, until the image request finishes.
  * @see sd_setImageWithURL:placeholderImage:options:
  * @see sd_setImageWithURL:placeholderImage:options:
  */
  */
-- (void)sd_setImageWithURL:(NSURL *)url placeholderImage:(UIImage *)placeholder;
+- (void)sd_setImageWithURL:(nullable NSURL *)url
+          placeholderImage:(nullable UIImage *)placeholder;
 
 
 /**
 /**
  * Set the imageView `image` with an `url`, placeholder and custom options.
  * Set the imageView `image` with an `url`, placeholder and custom options.
@@ -52,7 +53,9 @@
  * @param options     The options to use when downloading the image. @see SDWebImageOptions for the possible values.
  * @param options     The options to use when downloading the image. @see SDWebImageOptions for the possible values.
  */
  */
 
 
-- (void)sd_setImageWithURL:(NSURL *)url placeholderImage:(UIImage *)placeholder options:(SDWebImageOptions)options;
+- (void)sd_setImageWithURL:(nullable NSURL *)url
+          placeholderImage:(nullable UIImage *)placeholder
+                   options:(SDWebImageOptions)options;
 
 
 /**
 /**
  * Set the imageView `image` with an `url`.
  * Set the imageView `image` with an `url`.
@@ -66,7 +69,8 @@
  *                       indicating if the image was retrieved from the local cache or from the network.
  *                       indicating if the image was retrieved from the local cache or from the network.
  *                       The fourth parameter is the original image url.
  *                       The fourth parameter is the original image url.
  */
  */
-- (void)sd_setImageWithURL:(NSURL *)url completed:(SDExternalCompletionBlock)completedBlock;
+- (void)sd_setImageWithURL:(nullable NSURL *)url
+                 completed:(nullable SDExternalCompletionBlock)completedBlock;
 
 
 /**
 /**
  * Set the imageView `image` with an `url`, placeholder.
  * Set the imageView `image` with an `url`, placeholder.
@@ -81,7 +85,9 @@
  *                       indicating if the image was retrieved from the local cache or from the network.
  *                       indicating if the image was retrieved from the local cache or from the network.
  *                       The fourth parameter is the original image url.
  *                       The fourth parameter is the original image url.
  */
  */
-- (void)sd_setImageWithURL:(NSURL *)url placeholderImage:(UIImage *)placeholder completed:(SDExternalCompletionBlock)completedBlock;
+- (void)sd_setImageWithURL:(nullable NSURL *)url
+          placeholderImage:(nullable UIImage *)placeholder
+                 completed:(nullable SDExternalCompletionBlock)completedBlock;
 
 
 /**
 /**
  * Set the imageView `image` with an `url`, placeholder and custom options.
  * Set the imageView `image` with an `url`, placeholder and custom options.
@@ -97,7 +103,10 @@
  *                       indicating if the image was retrieved from the local cache or from the network.
  *                       indicating if the image was retrieved from the local cache or from the network.
  *                       The fourth parameter is the original image url.
  *                       The fourth parameter is the original image url.
  */
  */
-- (void)sd_setImageWithURL:(NSURL *)url placeholderImage:(UIImage *)placeholder options:(SDWebImageOptions)options completed:(SDExternalCompletionBlock)completedBlock;
+- (void)sd_setImageWithURL:(nullable NSURL *)url
+          placeholderImage:(nullable UIImage *)placeholder
+                   options:(SDWebImageOptions)options
+                 completed:(nullable SDExternalCompletionBlock)completedBlock;
 
 
 /**
 /**
  * Cancel the current download
  * Cancel the current download

@@ -14,31 +14,34 @@ static char imageURLKey;
 
 
 @implementation MKAnnotationView (WebCache)
 @implementation MKAnnotationView (WebCache)
 
 
-- (NSURL *)sd_imageURL {
+- (nullable NSURL *)sd_imageURL {
     return objc_getAssociatedObject(self, &imageURLKey);
     return objc_getAssociatedObject(self, &imageURLKey);
 }
 }
 
 
-- (void)sd_setImageWithURL:(NSURL *)url {
+- (void)sd_setImageWithURL:(nullable NSURL *)url {
     [self sd_setImageWithURL:url placeholderImage:nil options:0 completed:nil];
     [self sd_setImageWithURL:url placeholderImage:nil options:0 completed:nil];
 }
 }
 
 
-- (void)sd_setImageWithURL:(NSURL *)url placeholderImage:(UIImage *)placeholder {
+- (void)sd_setImageWithURL:(nullable NSURL *)url placeholderImage:(nullable UIImage *)placeholder {
     [self sd_setImageWithURL:url placeholderImage:placeholder options:0 completed:nil];
     [self sd_setImageWithURL:url placeholderImage:placeholder options:0 completed:nil];
 }
 }
 
 
-- (void)sd_setImageWithURL:(NSURL *)url placeholderImage:(UIImage *)placeholder options:(SDWebImageOptions)options {
+- (void)sd_setImageWithURL:(nullable NSURL *)url placeholderImage:(nullable UIImage *)placeholder options:(SDWebImageOptions)options {
     [self sd_setImageWithURL:url placeholderImage:placeholder options:options completed:nil];
     [self sd_setImageWithURL:url placeholderImage:placeholder options:options completed:nil];
 }
 }
 
 
-- (void)sd_setImageWithURL:(NSURL *)url completed:(SDExternalCompletionBlock)completedBlock {
+- (void)sd_setImageWithURL:(nullable NSURL *)url completed:(nullable SDExternalCompletionBlock)completedBlock {
     [self sd_setImageWithURL:url placeholderImage:nil options:0 completed:completedBlock];
     [self sd_setImageWithURL:url placeholderImage:nil options:0 completed:completedBlock];
 }
 }
 
 
-- (void)sd_setImageWithURL:(NSURL *)url placeholderImage:(UIImage *)placeholder completed:(SDExternalCompletionBlock)completedBlock {
+- (void)sd_setImageWithURL:(nullable NSURL *)url placeholderImage:(nullable UIImage *)placeholder completed:(nullable SDExternalCompletionBlock)completedBlock {
     [self sd_setImageWithURL:url placeholderImage:placeholder options:0 completed:completedBlock];
     [self sd_setImageWithURL:url placeholderImage:placeholder options:0 completed:completedBlock];
 }
 }
 
 
-- (void)sd_setImageWithURL:(NSURL *)url placeholderImage:(UIImage *)placeholder options:(SDWebImageOptions)options completed:(SDExternalCompletionBlock)completedBlock {
+- (void)sd_setImageWithURL:(nullable NSURL *)url
+          placeholderImage:(nullable UIImage *)placeholder
+                   options:(SDWebImageOptions)options
+                 completed:(nullable SDExternalCompletionBlock)completedBlock {
     [self sd_cancelCurrentImageLoad];
     [self sd_cancelCurrentImageLoad];
 
 
     objc_setAssociatedObject(self, &imageURLKey, url, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
     objc_setAssociatedObject(self, &imageURLKey, url, OBJC_ASSOCIATION_RETAIN_NONATOMIC);

@@ -18,6 +18,6 @@
  *
  *
  *  @return the content type as string (i.e. image/jpeg, image/gif)
  *  @return the content type as string (i.e. image/jpeg, image/gif)
  */
  */
-+ (NSString *)sd_contentTypeForImageData:(NSData *)data;
++ (nullable NSString *)sd_contentTypeForImageData:(nullable NSData *)data;
 
 
 @end
 @end

@@ -12,7 +12,11 @@
 
 
 @implementation NSData (ImageContentType)
 @implementation NSData (ImageContentType)
 
 
-+ (NSString *)sd_contentTypeForImageData:(NSData *)data {
++ (nullable NSString *)sd_contentTypeForImageData:(nullable NSData *)data {
+    if (!data) {
+        return nil;
+    }
+
     uint8_t c;
     uint8_t c;
     [data getBytes:&c length:1];
     [data getBytes:&c length:1];
     switch (c) {
     switch (c) {

@@ -24,7 +24,7 @@ typedef NS_ENUM(NSInteger, SDImageCacheType) {
     SDImageCacheTypeMemory
     SDImageCacheTypeMemory
 };
 };
 
 
-typedef void(^SDCacheQueryCompletedBlock)(UIImage *image, NSData *data, SDImageCacheType cacheType);
+typedef void(^SDCacheQueryCompletedBlock)(UIImage * _Nullable image, NSData * _Nullable data, SDImageCacheType cacheType);
 
 
 typedef void(^SDWebImageCheckCacheCompletionBlock)(BOOL isInCache);
 typedef void(^SDWebImageCheckCacheCompletionBlock)(BOOL isInCache);
 
 
@@ -77,14 +77,14 @@ typedef void(^SDWebImageCalculateSizeBlock)(NSUInteger fileCount, NSUInteger tot
  *
  *
  * @return SDImageCache global instance
  * @return SDImageCache global instance
  */
  */
-+ (SDImageCache *)sharedImageCache;
++ (nonnull SDImageCache *)sharedImageCache;
 
 
 /**
 /**
  * Init a new cache store with a specific namespace
  * Init a new cache store with a specific namespace
  *
  *
  * @param ns The namespace to use for this cache store
  * @param ns The namespace to use for this cache store
  */
  */
-- (instancetype)initWithNamespace:(NSString *)ns;
+- (nonnull instancetype)initWithNamespace:(nonnull NSString *)ns;
 
 
 /**
 /**
  * Init a new cache store with a specific namespace and directory
  * Init a new cache store with a specific namespace and directory
@@ -92,10 +92,10 @@ typedef void(^SDWebImageCalculateSizeBlock)(NSUInteger fileCount, NSUInteger tot
  * @param ns        The namespace to use for this cache store
  * @param ns        The namespace to use for this cache store
  * @param directory Directory to cache disk images in
  * @param directory Directory to cache disk images in
  */
  */
-- (instancetype)initWithNamespace:(NSString *)ns
-               diskCacheDirectory:(NSString *)directory NS_DESIGNATED_INITIALIZER;
+- (nonnull instancetype)initWithNamespace:(nonnull NSString *)ns
+                       diskCacheDirectory:(nonnull NSString *)directory NS_DESIGNATED_INITIALIZER;
 
 
--(NSString *)makeDiskCachePath:(NSString*)fullNamespace;
+- (nullable NSString *)makeDiskCachePath:(nonnull NSString*)fullNamespace;
 
 
 /**
 /**
  * Add a read-only cache path to search for images pre-cached by SDImageCache
  * Add a read-only cache path to search for images pre-cached by SDImageCache
@@ -103,7 +103,7 @@ typedef void(^SDWebImageCalculateSizeBlock)(NSUInteger fileCount, NSUInteger tot
  *
  *
  * @param path The path to use for this read-only cache path
  * @param path The path to use for this read-only cache path
  */
  */
-- (void)addReadOnlyCachePath:(NSString *)path;
+- (void)addReadOnlyCachePath:(nonnull NSString *)path;
 
 
 /**
 /**
  * Store an image into memory and disk cache at the given key.
  * Store an image into memory and disk cache at the given key.
@@ -111,7 +111,7 @@ typedef void(^SDWebImageCalculateSizeBlock)(NSUInteger fileCount, NSUInteger tot
  * @param image The image to store
  * @param image The image to store
  * @param key   The unique image cache key, usually it's image absolute URL
  * @param key   The unique image cache key, usually it's image absolute URL
  */
  */
-- (void)storeImage:(UIImage *)image forKey:(NSString *)key;
+- (void)storeImage:(nullable UIImage *)image forKey:(nullable NSString *)key;
 
 
 /**
 /**
  * Store an image into memory and optionally disk cache at the given key.
  * Store an image into memory and optionally disk cache at the given key.
@@ -120,7 +120,7 @@ typedef void(^SDWebImageCalculateSizeBlock)(NSUInteger fileCount, NSUInteger tot
  * @param key    The unique image cache key, usually it's image absolute URL
  * @param key    The unique image cache key, usually it's image absolute URL
  * @param toDisk Store the image to disk cache if YES
  * @param toDisk Store the image to disk cache if YES
  */
  */
-- (void)storeImage:(UIImage *)image forKey:(NSString *)key toDisk:(BOOL)toDisk;
+- (void)storeImage:(nullable UIImage *)image forKey:(nullable NSString *)key toDisk:(BOOL)toDisk;
 
 
 /**
 /**
  * Store an image into memory and optionally disk cache at the given key.
  * Store an image into memory and optionally disk cache at the given key.
@@ -133,7 +133,7 @@ typedef void(^SDWebImageCalculateSizeBlock)(NSUInteger fileCount, NSUInteger tot
  * @param key         The unique image cache key, usually it's image absolute URL
  * @param key         The unique image cache key, usually it's image absolute URL
  * @param toDisk      Store the image to disk cache if YES
  * @param toDisk      Store the image to disk cache if YES
  */
  */
-- (void)storeImage:(UIImage *)image recalculateFromImage:(BOOL)recalculate imageData:(NSData *)imageData forKey:(NSString *)key toDisk:(BOOL)toDisk;
+- (void)storeImage:(nullable UIImage *)image recalculateFromImage:(BOOL)recalculate imageData:(nullable NSData *)imageData forKey:(nullable NSString *)key toDisk:(BOOL)toDisk;
 
 
 /**
 /**
  * Store image NSData into disk cache at the given key.
  * Store image NSData into disk cache at the given key.
@@ -141,35 +141,35 @@ typedef void(^SDWebImageCalculateSizeBlock)(NSUInteger fileCount, NSUInteger tot
  * @param imageData The image data to store
  * @param imageData The image data to store
  * @param key   The unique image cache key, usually it's image absolute URL
  * @param key   The unique image cache key, usually it's image absolute URL
  */
  */
-- (void)storeImageDataToDisk:(NSData *)imageData forKey:(NSString *)key;
+- (void)storeImageDataToDisk:(nullable NSData *)imageData forKey:(nullable NSString *)key;
 
 
 /**
 /**
  * Query the disk cache asynchronously.
  * Query the disk cache asynchronously.
  *
  *
  * @param key The unique key used to store the wanted image
  * @param key The unique key used to store the wanted image
  */
  */
-- (NSOperation *)queryDiskCacheForKey:(NSString *)key done:(SDCacheQueryCompletedBlock)doneBlock;
+- (nullable NSOperation *)queryDiskCacheForKey:(nullable NSString *)key done:(nullable SDCacheQueryCompletedBlock)doneBlock;
 
 
 /**
 /**
  * Query the memory cache synchronously.
  * Query the memory cache synchronously.
  *
  *
  * @param key The unique key used to store the wanted image
  * @param key The unique key used to store the wanted image
  */
  */
-- (UIImage *)imageFromMemoryCacheForKey:(NSString *)key;
+- (nullable UIImage *)imageFromMemoryCacheForKey:(nullable NSString *)key;
 
 
 /**
 /**
  * Query the disk cache synchronously after checking the memory cache.
  * Query the disk cache synchronously after checking the memory cache.
  *
  *
  * @param key The unique key used to store the wanted image
  * @param key The unique key used to store the wanted image
  */
  */
-- (UIImage *)imageFromDiskCacheForKey:(NSString *)key;
+- (nullable UIImage *)imageFromDiskCacheForKey:(nullable NSString *)key;
 
 
 /**
 /**
  * Remove the image from memory and disk cache asynchronously
  * Remove the image from memory and disk cache asynchronously
  *
  *
  * @param key The unique image cache key
  * @param key The unique image cache key
  */
  */
-- (void)removeImageForKey:(NSString *)key;
+- (void)removeImageForKey:(nullable NSString *)key;
 
 
 
 
 /**
 /**
@@ -178,7 +178,7 @@ typedef void(^SDWebImageCalculateSizeBlock)(NSUInteger fileCount, NSUInteger tot
  * @param key             The unique image cache key
  * @param key             The unique image cache key
  * @param completion      An block that should be executed after the image has been removed (optional)
  * @param completion      An block that should be executed after the image has been removed (optional)
  */
  */
-- (void)removeImageForKey:(NSString *)key withCompletion:(SDWebImageNoParamsBlock)completion;
+- (void)removeImageForKey:(nullable NSString *)key withCompletion:(nullable SDWebImageNoParamsBlock)completion;
 
 
 /**
 /**
  * Remove the image from memory and optionally disk cache asynchronously
  * Remove the image from memory and optionally disk cache asynchronously
@@ -186,7 +186,7 @@ typedef void(^SDWebImageCalculateSizeBlock)(NSUInteger fileCount, NSUInteger tot
  * @param key      The unique image cache key
  * @param key      The unique image cache key
  * @param fromDisk Also remove cache entry from disk if YES
  * @param fromDisk Also remove cache entry from disk if YES
  */
  */
-- (void)removeImageForKey:(NSString *)key fromDisk:(BOOL)fromDisk;
+- (void)removeImageForKey:(nullable NSString *)key fromDisk:(BOOL)fromDisk;
 
 
 /**
 /**
  * Remove the image from memory and optionally disk cache asynchronously
  * Remove the image from memory and optionally disk cache asynchronously
@@ -195,7 +195,7 @@ typedef void(^SDWebImageCalculateSizeBlock)(NSUInteger fileCount, NSUInteger tot
  * @param fromDisk        Also remove cache entry from disk if YES
  * @param fromDisk        Also remove cache entry from disk if YES
  * @param completion      An block that should be executed after the image has been removed (optional)
  * @param completion      An block that should be executed after the image has been removed (optional)
  */
  */
-- (void)removeImageForKey:(NSString *)key fromDisk:(BOOL)fromDisk withCompletion:(SDWebImageNoParamsBlock)completion;
+- (void)removeImageForKey:(nullable NSString *)key fromDisk:(BOOL)fromDisk withCompletion:(nullable SDWebImageNoParamsBlock)completion;
 
 
 /**
 /**
  * Clear all memory cached images
  * Clear all memory cached images
@@ -206,7 +206,7 @@ typedef void(^SDWebImageCalculateSizeBlock)(NSUInteger fileCount, NSUInteger tot
  * Clear all disk cached images. Non-blocking method - returns immediately.
  * Clear all disk cached images. Non-blocking method - returns immediately.
  * @param completion    An block that should be executed after cache expiration completes (optional)
  * @param completion    An block that should be executed after cache expiration completes (optional)
  */
  */
-- (void)clearDiskOnCompletion:(SDWebImageNoParamsBlock)completion;
+- (void)clearDiskOnCompletion:(nullable SDWebImageNoParamsBlock)completion;
 
 
 /**
 /**
  * Clear all disk cached images
  * Clear all disk cached images
@@ -218,7 +218,7 @@ typedef void(^SDWebImageCalculateSizeBlock)(NSUInteger fileCount, NSUInteger tot
  * Remove all expired cached image from disk. Non-blocking method - returns immediately.
  * Remove all expired cached image from disk. Non-blocking method - returns immediately.
  * @param completionBlock An block that should be executed after cache expiration completes (optional)
  * @param completionBlock An block that should be executed after cache expiration completes (optional)
  */
  */
-- (void)cleanDiskWithCompletionBlock:(SDWebImageNoParamsBlock)completionBlock;
+- (void)cleanDiskWithCompletionBlock:(nullable SDWebImageNoParamsBlock)completionBlock;
 
 
 /**
 /**
  * Remove all expired cached image from disk
  * Remove all expired cached image from disk
@@ -239,7 +239,7 @@ typedef void(^SDWebImageCalculateSizeBlock)(NSUInteger fileCount, NSUInteger tot
 /**
 /**
  * Asynchronously calculate the disk cache's size.
  * Asynchronously calculate the disk cache's size.
  */
  */
-- (void)calculateSizeWithCompletionBlock:(SDWebImageCalculateSizeBlock)completionBlock;
+- (void)calculateSizeWithCompletionBlock:(nullable SDWebImageCalculateSizeBlock)completionBlock;
 
 
 /**
 /**
  *  Async check if image exists in disk cache already (does not load the image)
  *  Async check if image exists in disk cache already (does not load the image)
@@ -248,7 +248,7 @@ typedef void(^SDWebImageCalculateSizeBlock)(NSUInteger fileCount, NSUInteger tot
  *  @param completionBlock the block to be executed when the check is done.
  *  @param completionBlock the block to be executed when the check is done.
  *  @note the completion block will be always executed on the main queue
  *  @note the completion block will be always executed on the main queue
  */
  */
-- (void)diskImageExistsWithKey:(NSString *)key completion:(SDWebImageCheckCacheCompletionBlock)completionBlock;
+- (void)diskImageExistsWithKey:(nullable NSString *)key completion:(nullable SDWebImageCheckCacheCompletionBlock)completionBlock;
 
 
 /**
 /**
  *  Check if image exists in disk cache already (does not load the image)
  *  Check if image exists in disk cache already (does not load the image)
@@ -257,7 +257,7 @@ typedef void(^SDWebImageCalculateSizeBlock)(NSUInteger fileCount, NSUInteger tot
  *
  *
  *  @return YES if an image exists for the given key
  *  @return YES if an image exists for the given key
  */
  */
-- (BOOL)diskImageExistsWithKey:(NSString *)key;
+- (BOOL)diskImageExistsWithKey:(nullable NSString *)key;
 
 
 /**
 /**
  *  Get the cache path for a certain key (needs the cache path root folder)
  *  Get the cache path for a certain key (needs the cache path root folder)
@@ -267,7 +267,7 @@ typedef void(^SDWebImageCalculateSizeBlock)(NSUInteger fileCount, NSUInteger tot
  *
  *
  *  @return the cache path
  *  @return the cache path
  */
  */
-- (NSString *)cachePathForKey:(NSString *)key inPath:(NSString *)path;
+- (nullable NSString *)cachePathForKey:(nullable NSString *)key inPath:(nonnull NSString *)path;
 
 
 /**
 /**
  *  Get the default cache path for a certain key
  *  Get the default cache path for a certain key
@@ -276,6 +276,6 @@ typedef void(^SDWebImageCalculateSizeBlock)(NSUInteger fileCount, NSUInteger tot
  *
  *
  *  @return the default cache path
  *  @return the default cache path
  */
  */
-- (NSString *)defaultCachePathForKey:(NSString *)key;
+- (nullable NSString *)defaultCachePathForKey:(nullable NSString *)key;
 
 
 @end
 @end

@@ -18,8 +18,7 @@
 
 
 @implementation AutoPurgeCache
 @implementation AutoPurgeCache
 
 
-- (id)init
-{
+- (nonnull instancetype)init {
     self = [super init];
     self = [super init];
     if (self) {
     if (self) {
         [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(removeAllObjects) name:UIApplicationDidReceiveMemoryWarningNotification object:nil];
         [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(removeAllObjects) name:UIApplicationDidReceiveMemoryWarningNotification object:nil];
@@ -27,8 +26,7 @@
     return self;
     return self;
 }
 }
 
 
-- (void)dealloc
-{
+- (void)dealloc {
     [[NSNotificationCenter defaultCenter] removeObserver:self name:UIApplicationDidReceiveMemoryWarningNotification object:nil];
     [[NSNotificationCenter defaultCenter] removeObserver:self name:UIApplicationDidReceiveMemoryWarningNotification object:nil];
 
 
 }
 }
@@ -59,10 +57,10 @@ FOUNDATION_STATIC_INLINE NSUInteger SDCacheCostForImage(UIImage *image) {
 
 
 @interface SDImageCache ()
 @interface SDImageCache ()
 
 
-@property (strong, nonatomic) NSCache *memCache;
-@property (strong, nonatomic) NSString *diskCachePath;
-@property (strong, nonatomic) NSMutableArray *customPaths;
-@property (SDDispatchQueueSetterSementics, nonatomic) dispatch_queue_t ioQueue;
+@property (strong, nonatomic, nonnull) NSCache *memCache;
+@property (strong, nonatomic, nonnull) NSString *diskCachePath;
+@property (strong, nonatomic, nullable) NSMutableArray<NSString *> *customPaths;
+@property (SDDispatchQueueSetterSementics, nonatomic, nullable) dispatch_queue_t ioQueue;
 
 
 @end
 @end
 
 
@@ -71,7 +69,7 @@ FOUNDATION_STATIC_INLINE NSUInteger SDCacheCostForImage(UIImage *image) {
     NSFileManager *_fileManager;
     NSFileManager *_fileManager;
 }
 }
 
 
-+ (SDImageCache *)sharedImageCache {
++ (nonnull SDImageCache *)sharedImageCache {
     static dispatch_once_t once;
     static dispatch_once_t once;
     static id instance;
     static id instance;
     dispatch_once(&once, ^{
     dispatch_once(&once, ^{
@@ -84,12 +82,13 @@ FOUNDATION_STATIC_INLINE NSUInteger SDCacheCostForImage(UIImage *image) {
     return [self initWithNamespace:@"default"];
     return [self initWithNamespace:@"default"];
 }
 }
 
 
-- (instancetype)initWithNamespace:(NSString *)ns {
+- (nonnull instancetype)initWithNamespace:(nonnull NSString *)ns {
     NSString *path = [self makeDiskCachePath:ns];
     NSString *path = [self makeDiskCachePath:ns];
     return [self initWithNamespace:ns diskCacheDirectory:path];
     return [self initWithNamespace:ns diskCacheDirectory:path];
 }
 }
 
 
-- (instancetype)initWithNamespace:(NSString *)ns diskCacheDirectory:(NSString *)directory {
+- (nonnull instancetype)initWithNamespace:(nonnull NSString *)ns
+                       diskCacheDirectory:(nonnull NSString *)directory {
     if ((self = [super init])) {
     if ((self = [super init])) {
         NSString *fullNamespace = [@"com.hackemist.SDWebImageCache." stringByAppendingString:ns];
         NSString *fullNamespace = [@"com.hackemist.SDWebImageCache." stringByAppendingString:ns];
 
 
@@ -154,7 +153,7 @@ FOUNDATION_STATIC_INLINE NSUInteger SDCacheCostForImage(UIImage *image) {
     SDDispatchQueueRelease(_ioQueue);
     SDDispatchQueueRelease(_ioQueue);
 }
 }
 
 
-- (void)addReadOnlyCachePath:(NSString *)path {
+- (void)addReadOnlyCachePath:(nonnull NSString *)path {
     if (!self.customPaths) {
     if (!self.customPaths) {
         self.customPaths = [NSMutableArray new];
         self.customPaths = [NSMutableArray new];
     }
     }
@@ -164,18 +163,18 @@ FOUNDATION_STATIC_INLINE NSUInteger SDCacheCostForImage(UIImage *image) {
     }
     }
 }
 }
 
 
-- (NSString *)cachePathForKey:(NSString *)key inPath:(NSString *)path {
+- (nullable NSString *)cachePathForKey:(nullable NSString *)key inPath:(nonnull NSString *)path {
     NSString *filename = [self cachedFileNameForKey:key];
     NSString *filename = [self cachedFileNameForKey:key];
     return [path stringByAppendingPathComponent:filename];
     return [path stringByAppendingPathComponent:filename];
 }
 }
 
 
-- (NSString *)defaultCachePathForKey:(NSString *)key {
+- (nullable NSString *)defaultCachePathForKey:(nullable NSString *)key {
     return [self cachePathForKey:key inPath:self.diskCachePath];
     return [self cachePathForKey:key inPath:self.diskCachePath];
 }
 }
 
 
 #pragma mark SDImageCache (private)
 #pragma mark SDImageCache (private)
 
 
-- (NSString *)cachedFileNameForKey:(NSString *)key {
+- (nullable NSString *)cachedFileNameForKey:(nullable NSString *)key {
     const char *str = key.UTF8String;
     const char *str = key.UTF8String;
     if (str == NULL) {
     if (str == NULL) {
         str = "";
         str = "";
@@ -192,12 +191,12 @@ FOUNDATION_STATIC_INLINE NSUInteger SDCacheCostForImage(UIImage *image) {
 #pragma mark ImageCache
 #pragma mark ImageCache
 
 
 // Init the disk cache
 // Init the disk cache
--(NSString *)makeDiskCachePath:(NSString*)fullNamespace{
-    NSArray *paths = NSSearchPathForDirectoriesInDomains(NSCachesDirectory, NSUserDomainMask, YES);
+- (nullable NSString *)makeDiskCachePath:(nonnull NSString*)fullNamespace {
+    NSArray<NSString *> *paths = NSSearchPathForDirectoriesInDomains(NSCachesDirectory, NSUserDomainMask, YES);
     return [paths[0] stringByAppendingPathComponent:fullNamespace];
     return [paths[0] stringByAppendingPathComponent:fullNamespace];
 }
 }
 
 
-- (void)storeImage:(UIImage *)image recalculateFromImage:(BOOL)recalculate imageData:(NSData *)imageData forKey:(NSString *)key toDisk:(BOOL)toDisk {
+- (void)storeImage:(nullable UIImage *)image recalculateFromImage:(BOOL)recalculate imageData:(nullable NSData *)imageData forKey:(nullable  NSString *)key toDisk:(BOOL)toDisk {
     if (!image || !key) {
     if (!image || !key) {
         return;
         return;
     }
     }
@@ -247,15 +246,15 @@ FOUNDATION_STATIC_INLINE NSUInteger SDCacheCostForImage(UIImage *image) {
     }
     }
 }
 }
 
 
-- (void)storeImage:(UIImage *)image forKey:(NSString *)key {
+- (void)storeImage:(nullable UIImage *)image forKey:(nullable NSString *)key {
     [self storeImage:image recalculateFromImage:YES imageData:nil forKey:key toDisk:YES];
     [self storeImage:image recalculateFromImage:YES imageData:nil forKey:key toDisk:YES];
 }
 }
 
 
-- (void)storeImage:(UIImage *)image forKey:(NSString *)key toDisk:(BOOL)toDisk {
+- (void)storeImage:(nullable UIImage *)image forKey:(nullable NSString *)key toDisk:(BOOL)toDisk {
     [self storeImage:image recalculateFromImage:YES imageData:nil forKey:key toDisk:toDisk];
     [self storeImage:image recalculateFromImage:YES imageData:nil forKey:key toDisk:toDisk];
 }
 }
 
 
-- (void)storeImageDataToDisk:(NSData *)imageData forKey:(NSString *)key {
+- (void)storeImageDataToDisk:(nullable NSData *)imageData forKey:(nullable NSString *)key {
     
     
     if (!imageData) {
     if (!imageData) {
         return;
         return;
@@ -278,7 +277,7 @@ FOUNDATION_STATIC_INLINE NSUInteger SDCacheCostForImage(UIImage *image) {
     }
     }
 }
 }
 
 
-- (BOOL)diskImageExistsWithKey:(NSString *)key {
+- (BOOL)diskImageExistsWithKey:(nullable NSString *)key {
     BOOL exists = NO;
     BOOL exists = NO;
     
     
     // this is an exception to access the filemanager on another queue than ioQueue, but we are using the shared instance
     // this is an exception to access the filemanager on another queue than ioQueue, but we are using the shared instance
@@ -294,7 +293,7 @@ FOUNDATION_STATIC_INLINE NSUInteger SDCacheCostForImage(UIImage *image) {
     return exists;
     return exists;
 }
 }
 
 
-- (void)diskImageExistsWithKey:(NSString *)key completion:(SDWebImageCheckCacheCompletionBlock)completionBlock {
+- (void)diskImageExistsWithKey:(nullable NSString *)key completion:(nullable SDWebImageCheckCacheCompletionBlock)completionBlock {
     dispatch_async(_ioQueue, ^{
     dispatch_async(_ioQueue, ^{
         BOOL exists = [_fileManager fileExistsAtPath:[self defaultCachePathForKey:key]];
         BOOL exists = [_fileManager fileExistsAtPath:[self defaultCachePathForKey:key]];
 
 
@@ -312,11 +311,11 @@ FOUNDATION_STATIC_INLINE NSUInteger SDCacheCostForImage(UIImage *image) {
     });
     });
 }
 }
 
 
-- (UIImage *)imageFromMemoryCacheForKey:(NSString *)key {
+- (nullable UIImage *)imageFromMemoryCacheForKey:(nullable NSString *)key {
     return [self.memCache objectForKey:key];
     return [self.memCache objectForKey:key];
 }
 }
 
 
-- (UIImage *)imageFromDiskCacheForKey:(NSString *)key {
+- (nullable UIImage *)imageFromDiskCacheForKey:(nullable NSString *)key {
 
 
     // First check the in-memory cache...
     // First check the in-memory cache...
     UIImage *image = [self imageFromMemoryCacheForKey:key];
     UIImage *image = [self imageFromMemoryCacheForKey:key];
@@ -334,7 +333,7 @@ FOUNDATION_STATIC_INLINE NSUInteger SDCacheCostForImage(UIImage *image) {
     return diskImage;
     return diskImage;
 }
 }
 
 
-- (NSData *)diskImageDataBySearchingAllPathsForKey:(NSString *)key {
+- (nullable NSData *)diskImageDataBySearchingAllPathsForKey:(nullable NSString *)key {
     NSString *defaultPath = [self defaultCachePathForKey:key];
     NSString *defaultPath = [self defaultCachePathForKey:key];
     NSData *data = [NSData dataWithContentsOfFile:defaultPath];
     NSData *data = [NSData dataWithContentsOfFile:defaultPath];
     if (data) {
     if (data) {
@@ -348,7 +347,7 @@ FOUNDATION_STATIC_INLINE NSUInteger SDCacheCostForImage(UIImage *image) {
         return data;
         return data;
     }
     }
 
 
-    NSArray *customPaths = [self.customPaths copy];
+    NSArray<NSString *> *customPaths = [self.customPaths copy];
     for (NSString *path in customPaths) {
     for (NSString *path in customPaths) {
         NSString *filePath = [self cachePathForKey:key inPath:path];
         NSString *filePath = [self cachePathForKey:key inPath:path];
         NSData *imageData = [NSData dataWithContentsOfFile:filePath];
         NSData *imageData = [NSData dataWithContentsOfFile:filePath];
@@ -367,7 +366,7 @@ FOUNDATION_STATIC_INLINE NSUInteger SDCacheCostForImage(UIImage *image) {
     return nil;
     return nil;
 }
 }
 
 
-- (UIImage *)diskImageForKey:(NSString *)key {
+- (nullable UIImage *)diskImageForKey:(nullable NSString *)key {
     NSData *data = [self diskImageDataBySearchingAllPathsForKey:key];
     NSData *data = [self diskImageDataBySearchingAllPathsForKey:key];
     if (data) {
     if (data) {
         UIImage *image = [UIImage sd_imageWithData:data];
         UIImage *image = [UIImage sd_imageWithData:data];
@@ -382,11 +381,11 @@ FOUNDATION_STATIC_INLINE NSUInteger SDCacheCostForImage(UIImage *image) {
     }
     }
 }
 }
 
 
-- (UIImage *)scaledImageForKey:(NSString *)key image:(UIImage *)image {
+- (nullable UIImage *)scaledImageForKey:(nullable NSString *)key image:(nullable UIImage *)image {
     return SDScaledImageForKey(key, image);
     return SDScaledImageForKey(key, image);
 }
 }
 
 
-- (NSOperation *)queryDiskCacheForKey:(NSString *)key done:(SDCacheQueryCompletedBlock)doneBlock {
+- (nullable NSOperation *)queryDiskCacheForKey:(nullable NSString *)key done:(nullable SDCacheQueryCompletedBlock)doneBlock {
     if (!doneBlock) {
     if (!doneBlock) {
         return nil;
         return nil;
     }
     }
@@ -430,19 +429,19 @@ FOUNDATION_STATIC_INLINE NSUInteger SDCacheCostForImage(UIImage *image) {
     return operation;
     return operation;
 }
 }
 
 
-- (void)removeImageForKey:(NSString *)key {
+- (void)removeImageForKey:(nullable NSString *)key {
     [self removeImageForKey:key withCompletion:nil];
     [self removeImageForKey:key withCompletion:nil];
 }
 }
 
 
-- (void)removeImageForKey:(NSString *)key withCompletion:(SDWebImageNoParamsBlock)completion {
+- (void)removeImageForKey:(nullable NSString *)key withCompletion:(nullable SDWebImageNoParamsBlock)completion {
     [self removeImageForKey:key fromDisk:YES withCompletion:completion];
     [self removeImageForKey:key fromDisk:YES withCompletion:completion];
 }
 }
 
 
-- (void)removeImageForKey:(NSString *)key fromDisk:(BOOL)fromDisk {
+- (void)removeImageForKey:(nullable NSString *)key fromDisk:(BOOL)fromDisk {
     [self removeImageForKey:key fromDisk:fromDisk withCompletion:nil];
     [self removeImageForKey:key fromDisk:fromDisk withCompletion:nil];
 }
 }
 
 
-- (void)removeImageForKey:(NSString *)key fromDisk:(BOOL)fromDisk withCompletion:(SDWebImageNoParamsBlock)completion {
+- (void)removeImageForKey:(nullable NSString *)key fromDisk:(BOOL)fromDisk withCompletion:(nullable SDWebImageNoParamsBlock)completion {
     
     
     if (key == nil) {
     if (key == nil) {
         return;
         return;
@@ -492,8 +491,7 @@ FOUNDATION_STATIC_INLINE NSUInteger SDCacheCostForImage(UIImage *image) {
     [self clearDiskOnCompletion:nil];
     [self clearDiskOnCompletion:nil];
 }
 }
 
 
-- (void)clearDiskOnCompletion:(SDWebImageNoParamsBlock)completion
-{
+- (void)clearDiskOnCompletion:(nullable SDWebImageNoParamsBlock)completion {
     dispatch_async(self.ioQueue, ^{
     dispatch_async(self.ioQueue, ^{
         [_fileManager removeItemAtPath:self.diskCachePath error:nil];
         [_fileManager removeItemAtPath:self.diskCachePath error:nil];
         [_fileManager createDirectoryAtPath:self.diskCachePath
         [_fileManager createDirectoryAtPath:self.diskCachePath
@@ -513,10 +511,10 @@ FOUNDATION_STATIC_INLINE NSUInteger SDCacheCostForImage(UIImage *image) {
     [self cleanDiskWithCompletionBlock:nil];
     [self cleanDiskWithCompletionBlock:nil];
 }
 }
 
 
-- (void)cleanDiskWithCompletionBlock:(SDWebImageNoParamsBlock)completionBlock {
+- (void)cleanDiskWithCompletionBlock:(nullable SDWebImageNoParamsBlock)completionBlock {
     dispatch_async(self.ioQueue, ^{
     dispatch_async(self.ioQueue, ^{
         NSURL *diskCacheURL = [NSURL fileURLWithPath:self.diskCachePath isDirectory:YES];
         NSURL *diskCacheURL = [NSURL fileURLWithPath:self.diskCachePath isDirectory:YES];
-        NSArray *resourceKeys = @[NSURLIsDirectoryKey, NSURLContentModificationDateKey, NSURLTotalFileAllocatedSizeKey];
+        NSArray<NSString *> *resourceKeys = @[NSURLIsDirectoryKey, NSURLContentModificationDateKey, NSURLTotalFileAllocatedSizeKey];
 
 
         // This enumerator prefetches useful properties for our cache files.
         // This enumerator prefetches useful properties for our cache files.
         NSDirectoryEnumerator *fileEnumerator = [_fileManager enumeratorAtURL:diskCacheURL
         NSDirectoryEnumerator *fileEnumerator = [_fileManager enumeratorAtURL:diskCacheURL
@@ -525,16 +523,16 @@ FOUNDATION_STATIC_INLINE NSUInteger SDCacheCostForImage(UIImage *image) {
                                                                  errorHandler:NULL];
                                                                  errorHandler:NULL];
 
 
         NSDate *expirationDate = [NSDate dateWithTimeIntervalSinceNow:-self.maxCacheAge];
         NSDate *expirationDate = [NSDate dateWithTimeIntervalSinceNow:-self.maxCacheAge];
-        NSMutableDictionary *cacheFiles = [NSMutableDictionary dictionary];
+        NSMutableDictionary<NSURL *, NSDictionary<NSString *, id> *> *cacheFiles = [NSMutableDictionary dictionary];
         NSUInteger currentCacheSize = 0;
         NSUInteger currentCacheSize = 0;
 
 
         // Enumerate all of the files in the cache directory.  This loop has two purposes:
         // Enumerate all of the files in the cache directory.  This loop has two purposes:
         //
         //
         //  1. Removing files that are older than the expiration date.
         //  1. Removing files that are older than the expiration date.
         //  2. Storing file attributes for the size-based cleanup pass.
         //  2. Storing file attributes for the size-based cleanup pass.
-        NSMutableArray *urlsToDelete = [[NSMutableArray alloc] init];
+        NSMutableArray<NSURL *> *urlsToDelete = [[NSMutableArray alloc] init];
         for (NSURL *fileURL in fileEnumerator) {
         for (NSURL *fileURL in fileEnumerator) {
-            NSDictionary *resourceValues = [fileURL resourceValuesForKeys:resourceKeys error:NULL];
+            NSDictionary<NSString *, id> *resourceValues = [fileURL resourceValuesForKeys:resourceKeys error:NULL];
 
 
             // Skip directories.
             // Skip directories.
             if ([resourceValues[NSURLIsDirectoryKey] boolValue]) {
             if ([resourceValues[NSURLIsDirectoryKey] boolValue]) {
@@ -565,15 +563,15 @@ FOUNDATION_STATIC_INLINE NSUInteger SDCacheCostForImage(UIImage *image) {
             const NSUInteger desiredCacheSize = self.maxCacheSize / 2;
             const NSUInteger desiredCacheSize = self.maxCacheSize / 2;
 
 
             // Sort the remaining cache files by their last modification time (oldest first).
             // Sort the remaining cache files by their last modification time (oldest first).
-            NSArray *sortedFiles = [cacheFiles keysSortedByValueWithOptions:NSSortConcurrent
-                                                            usingComparator:^NSComparisonResult(id obj1, id obj2) {
-                                                                return [obj1[NSURLContentModificationDateKey] compare:obj2[NSURLContentModificationDateKey]];
-                                                            }];
+            NSArray<NSURL *> *sortedFiles = [cacheFiles keysSortedByValueWithOptions:NSSortConcurrent
+                                                                     usingComparator:^NSComparisonResult(id obj1, id obj2) {
+                                                                         return [obj1[NSURLContentModificationDateKey] compare:obj2[NSURLContentModificationDateKey]];
+                                                                     }];
 
 
             // Delete files until we fall below our desired cache size.
             // Delete files until we fall below our desired cache size.
             for (NSURL *fileURL in sortedFiles) {
             for (NSURL *fileURL in sortedFiles) {
                 if ([_fileManager removeItemAtURL:fileURL error:nil]) {
                 if ([_fileManager removeItemAtURL:fileURL error:nil]) {
-                    NSDictionary *resourceValues = cacheFiles[fileURL];
+                    NSDictionary<NSString *, id> *resourceValues = cacheFiles[fileURL];
                     NSNumber *totalAllocatedSize = resourceValues[NSURLTotalFileAllocatedSizeKey];
                     NSNumber *totalAllocatedSize = resourceValues[NSURLTotalFileAllocatedSizeKey];
                     currentCacheSize -= totalAllocatedSize.unsignedIntegerValue;
                     currentCacheSize -= totalAllocatedSize.unsignedIntegerValue;
 
 
@@ -617,7 +615,7 @@ FOUNDATION_STATIC_INLINE NSUInteger SDCacheCostForImage(UIImage *image) {
         NSDirectoryEnumerator *fileEnumerator = [_fileManager enumeratorAtPath:self.diskCachePath];
         NSDirectoryEnumerator *fileEnumerator = [_fileManager enumeratorAtPath:self.diskCachePath];
         for (NSString *fileName in fileEnumerator) {
         for (NSString *fileName in fileEnumerator) {
             NSString *filePath = [self.diskCachePath stringByAppendingPathComponent:fileName];
             NSString *filePath = [self.diskCachePath stringByAppendingPathComponent:fileName];
-            NSDictionary *attrs = [[NSFileManager defaultManager] attributesOfItemAtPath:filePath error:nil];
+            NSDictionary<NSString *, id> *attrs = [[NSFileManager defaultManager] attributesOfItemAtPath:filePath error:nil];
             size += [attrs fileSize];
             size += [attrs fileSize];
         }
         }
     });
     });
@@ -633,7 +631,7 @@ FOUNDATION_STATIC_INLINE NSUInteger SDCacheCostForImage(UIImage *image) {
     return count;
     return count;
 }
 }
 
 
-- (void)calculateSizeWithCompletionBlock:(SDWebImageCalculateSizeBlock)completionBlock {
+- (void)calculateSizeWithCompletionBlock:(nullable SDWebImageCalculateSizeBlock)completionBlock {
     NSURL *diskCacheURL = [NSURL fileURLWithPath:self.diskCachePath isDirectory:YES];
     NSURL *diskCacheURL = [NSURL fileURLWithPath:self.diskCachePath isDirectory:YES];
 
 
     dispatch_async(self.ioQueue, ^{
     dispatch_async(self.ioQueue, ^{

@@ -12,13 +12,13 @@
 #error SDWebImage is ARC only. Either turn on ARC for the project or use -fobjc-arc flag
 #error SDWebImage is ARC only. Either turn on ARC for the project or use -fobjc-arc flag
 #endif
 #endif
 
 
-inline UIImage *SDScaledImageForKey(NSString *key, UIImage *image) {
+inline UIImage *SDScaledImageForKey(NSString * _Nullable key, UIImage * _Nullable image) {
     if (!image) {
     if (!image) {
         return nil;
         return nil;
     }
     }
     
     
     if ((image.images).count > 0) {
     if ((image.images).count > 0) {
-        NSMutableArray *scaledImages = [NSMutableArray array];
+        NSMutableArray<UIImage *> *scaledImages = [NSMutableArray array];
 
 
         for (UIImage *tempImage in image.images) {
         for (UIImage *tempImage in image.images) {
             [scaledImages addObject:SDScaledImageForKey(key, tempImage)];
             [scaledImages addObject:SDScaledImageForKey(key, tempImage)];

@@ -12,6 +12,6 @@
 
 
 @interface UIImage (ForceDecode)
 @interface UIImage (ForceDecode)
 
 
-+ (UIImage *)decodedImageWithImage:(UIImage *)image;
++ (nullable UIImage *)decodedImageWithImage:(nullable UIImage *)image;
 
 
 @end
 @end

@@ -11,7 +11,7 @@
 
 
 @implementation UIImage (ForceDecode)
 @implementation UIImage (ForceDecode)
 
 
-+ (UIImage *)decodedImageWithImage:(UIImage *)image {
++ (nullable UIImage *)decodedImageWithImage:(nullable UIImage *)image {
     // while downloading huge amount of images
     // while downloading huge amount of images
     // autorelease the bitmap context
     // autorelease the bitmap context
     // and all vars to help system to free memory
     // and all vars to help system to free memory

@@ -63,22 +63,25 @@ typedef NS_ENUM(NSInteger, SDWebImageDownloaderExecutionOrder) {
     SDWebImageDownloaderLIFOExecutionOrder
     SDWebImageDownloaderLIFOExecutionOrder
 };
 };
 
 
-extern NSString *const SDWebImageDownloadStartNotification;
-extern NSString *const SDWebImageDownloadStopNotification;
+extern NSString * _Nonnull const SDWebImageDownloadStartNotification;
+extern NSString * _Nonnull const SDWebImageDownloadStopNotification;
 
 
 typedef void(^SDWebImageDownloaderProgressBlock)(NSInteger receivedSize, NSInteger expectedSize);
 typedef void(^SDWebImageDownloaderProgressBlock)(NSInteger receivedSize, NSInteger expectedSize);
 
 
-typedef void(^SDWebImageDownloaderCompletedBlock)(UIImage *image, NSData *data, NSError *error, BOOL finished);
+typedef void(^SDWebImageDownloaderCompletedBlock)(UIImage * _Nullable image, NSData * _Nullable data, NSError * _Nullable error, BOOL finished);
 
 
-typedef NSDictionary *(^SDWebImageDownloaderHeadersFilterBlock)(NSURL *url, NSDictionary *headers);
+typedef NSDictionary<NSString *, NSString *> SDHTTPHeadersDictionary;
+typedef NSMutableDictionary<NSString *, NSString *> SDHTTPHeadersMutableDictionary;
+
+typedef SDHTTPHeadersDictionary * _Nullable (^SDWebImageDownloaderHeadersFilterBlock)(NSURL * _Nullable url, SDHTTPHeadersDictionary * _Nullable headers);
 
 
 /**
 /**
  *  A token associated with each download. Can be used to cancel a download
  *  A token associated with each download. Can be used to cancel a download
  */
  */
 @interface SDWebImageDownloadToken : NSObject
 @interface SDWebImageDownloadToken : NSObject
 
 
-@property (nonatomic, strong) NSURL *url;
-@property (nonatomic, strong) id downloadOperationCancelToken;
+@property (nonatomic, strong, nullable) NSURL *url;
+@property (nonatomic, strong, nullable) id downloadOperationCancelToken;
 
 
 @end
 @end
 
 
@@ -118,22 +121,22 @@ typedef NSDictionary *(^SDWebImageDownloaderHeadersFilterBlock)(NSURL *url, NSDi
  *
  *
  *  @return global shared instance of downloader class
  *  @return global shared instance of downloader class
  */
  */
-+ (SDWebImageDownloader *)sharedDownloader;
++ (nonnull SDWebImageDownloader *)sharedDownloader;
 
 
 /**
 /**
  *  Set the default URL credential to be set for request operations.
  *  Set the default URL credential to be set for request operations.
  */
  */
-@property (strong, nonatomic) NSURLCredential *urlCredential;
+@property (strong, nonatomic, nullable) NSURLCredential *urlCredential;
 
 
 /**
 /**
  * Set username
  * Set username
  */
  */
-@property (strong, nonatomic) NSString *username;
+@property (strong, nonatomic, nullable) NSString *username;
 
 
 /**
 /**
  * Set password
  * Set password
  */
  */
-@property (strong, nonatomic) NSString *password;
+@property (strong, nonatomic, nullable) NSString *password;
 
 
 /**
 /**
  * Set filter to pick headers for downloading image HTTP request.
  * Set filter to pick headers for downloading image HTTP request.
@@ -141,7 +144,7 @@ typedef NSDictionary *(^SDWebImageDownloaderHeadersFilterBlock)(NSURL *url, NSDi
  * This block will be invoked for each downloading image request, returned
  * This block will be invoked for each downloading image request, returned
  * NSDictionary will be used as headers in corresponding HTTP request.
  * NSDictionary will be used as headers in corresponding HTTP request.
  */
  */
-@property (nonatomic, copy) SDWebImageDownloaderHeadersFilterBlock headersFilter;
+@property (nonatomic, copy, nullable) SDWebImageDownloaderHeadersFilterBlock headersFilter;
 
 
 /**
 /**
  * Set a value for a HTTP header to be appended to each download HTTP request.
  * Set a value for a HTTP header to be appended to each download HTTP request.
@@ -149,14 +152,14 @@ typedef NSDictionary *(^SDWebImageDownloaderHeadersFilterBlock)(NSURL *url, NSDi
  * @param value The value for the header field. Use `nil` value to remove the header.
  * @param value The value for the header field. Use `nil` value to remove the header.
  * @param field The name of the header field to set.
  * @param field The name of the header field to set.
  */
  */
-- (void)setValue:(NSString *)value forHTTPHeaderField:(NSString *)field;
+- (void)setValue:(nullable NSString *)value forHTTPHeaderField:(nullable NSString *)field;
 
 
 /**
 /**
  * Returns the value of the specified HTTP header field.
  * Returns the value of the specified HTTP header field.
  *
  *
  * @return The value associated with the header field field, or `nil` if there is no corresponding header field.
  * @return The value associated with the header field field, or `nil` if there is no corresponding header field.
  */
  */
-- (NSString *)valueForHTTPHeaderField:(NSString *)field;
+- (nullable NSString *)valueForHTTPHeaderField:(nullable NSString *)field;
 
 
 /**
 /**
  * Sets a subclass of `SDWebImageDownloaderOperation` as the default
  * Sets a subclass of `SDWebImageDownloaderOperation` as the default
@@ -166,7 +169,7 @@ typedef NSDictionary *(^SDWebImageDownloaderHeadersFilterBlock)(NSURL *url, NSDi
  * @param operationClass The subclass of `SDWebImageDownloaderOperation` to set 
  * @param operationClass The subclass of `SDWebImageDownloaderOperation` to set 
  *        as default. Passing `nil` will revert to `SDWebImageDownloaderOperation`.
  *        as default. Passing `nil` will revert to `SDWebImageDownloaderOperation`.
  */
  */
-- (void)setOperationClass:(Class)operationClass;
+- (void)setOperationClass:(nullable Class)operationClass;
 
 
 /**
 /**
  * Creates a SDWebImageDownloader async downloader instance with a given URL
  * Creates a SDWebImageDownloader async downloader instance with a given URL
@@ -189,17 +192,17 @@ typedef NSDictionary *(^SDWebImageDownloaderHeadersFilterBlock)(NSURL *url, NSDi
  *
  *
  * @return A token (SDWebImageDownloadToken) that can be passed to -cancel: to cancel this operation
  * @return A token (SDWebImageDownloadToken) that can be passed to -cancel: to cancel this operation
  */
  */
-- (SDWebImageDownloadToken *)downloadImageWithURL:(NSURL *)url
-                                          options:(SDWebImageDownloaderOptions)options
-                                         progress:(SDWebImageDownloaderProgressBlock)progressBlock
-                                        completed:(SDWebImageDownloaderCompletedBlock)completedBlock;
+- (nullable SDWebImageDownloadToken *)downloadImageWithURL:(nullable NSURL *)url
+                                                   options:(SDWebImageDownloaderOptions)options
+                                                  progress:(nullable SDWebImageDownloaderProgressBlock)progressBlock
+                                                 completed:(nullable SDWebImageDownloaderCompletedBlock)completedBlock;
 
 
 /**
 /**
  * Cancels a download that was previously queued using -downloadImageWithURL:options:progress:completed:
  * Cancels a download that was previously queued using -downloadImageWithURL:options:progress:completed:
  *
  *
  * @param token The token received from -downloadImageWithURL:options:progress:completed: that should be canceled.
  * @param token The token received from -downloadImageWithURL:options:progress:completed: that should be canceled.
  */
  */
-- (void)cancel:(SDWebImageDownloadToken *)token;
+- (void)cancel:(nullable SDWebImageDownloadToken *)token;
 
 
 /**
 /**
  * Sets the download queue suspension state
  * Sets the download queue suspension state

@@ -16,13 +16,13 @@
 
 
 @interface SDWebImageDownloader () <NSURLSessionTaskDelegate, NSURLSessionDataDelegate>
 @interface SDWebImageDownloader () <NSURLSessionTaskDelegate, NSURLSessionDataDelegate>
 
 
-@property (strong, nonatomic) NSOperationQueue *downloadQueue;
-@property (weak, nonatomic) NSOperation *lastAddedOperation;
-@property (assign, nonatomic) Class operationClass;
-@property (strong, nonatomic) NSMutableDictionary *URLOperations;
-@property (strong, nonatomic) NSMutableDictionary *HTTPHeaders;
+@property (strong, nonatomic, nonnull) NSOperationQueue *downloadQueue;
+@property (weak, nonatomic, nullable) NSOperation *lastAddedOperation;
+@property (assign, nonatomic, nullable) Class operationClass;
+@property (strong, nonatomic, nonnull) NSMutableDictionary<NSURL *, SDWebImageDownloaderOperation *> *URLOperations;
+@property (strong, nonatomic, nullable) SDHTTPHeadersMutableDictionary *HTTPHeaders;
 // This queue is used to serialize the handling of the network responses of all the download operation in a single queue
 // 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;
+@property (SDDispatchQueueSetterSementics, nonatomic, nullable) dispatch_queue_t barrierQueue;
 
 
 // The session in which data tasks will run
 // The session in which data tasks will run
 @property (strong, nonatomic) NSURLSession *session;
 @property (strong, nonatomic) NSURLSession *session;
@@ -54,7 +54,7 @@
     }
     }
 }
 }
 
 
-+ (SDWebImageDownloader *)sharedDownloader {
++ (nonnull SDWebImageDownloader *)sharedDownloader {
     static dispatch_once_t once;
     static dispatch_once_t once;
     static id instance;
     static id instance;
     dispatch_once(&once, ^{
     dispatch_once(&once, ^{
@@ -63,7 +63,7 @@
     return instance;
     return instance;
 }
 }
 
 
-- (instancetype)init {
+- (nonnull instancetype)init {
     if ((self = [super init])) {
     if ((self = [super init])) {
         _operationClass = [SDWebImageDownloaderOperation class];
         _operationClass = [SDWebImageDownloaderOperation class];
         _shouldDecompressImages = YES;
         _shouldDecompressImages = YES;
@@ -102,7 +102,7 @@
     SDDispatchQueueRelease(_barrierQueue);
     SDDispatchQueueRelease(_barrierQueue);
 }
 }
 
 
-- (void)setValue:(NSString *)value forHTTPHeaderField:(NSString *)field {
+- (void)setValue:(nullable NSString *)value forHTTPHeaderField:(nullable NSString *)field {
     if (value) {
     if (value) {
         self.HTTPHeaders[field] = value;
         self.HTTPHeaders[field] = value;
     }
     }
@@ -111,7 +111,7 @@
     }
     }
 }
 }
 
 
-- (NSString *)valueForHTTPHeaderField:(NSString *)field {
+- (nullable NSString *)valueForHTTPHeaderField:(nullable NSString *)field {
     return self.HTTPHeaders[field];
     return self.HTTPHeaders[field];
 }
 }
 
 
@@ -127,14 +127,14 @@
     return _downloadQueue.maxConcurrentOperationCount;
     return _downloadQueue.maxConcurrentOperationCount;
 }
 }
 
 
-- (void)setOperationClass:(Class)operationClass {
+- (void)setOperationClass:(nullable Class)operationClass {
     _operationClass = operationClass ?: [SDWebImageDownloaderOperation class];
     _operationClass = operationClass ?: [SDWebImageDownloaderOperation class];
 }
 }
 
 
-- (SDWebImageDownloadToken *)downloadImageWithURL:(NSURL *)url
-                                          options:(SDWebImageDownloaderOptions)options
-                                         progress:(SDWebImageDownloaderProgressBlock)progressBlock
-                                        completed:(SDWebImageDownloaderCompletedBlock)completedBlock {
+- (nullable SDWebImageDownloadToken *)downloadImageWithURL:(nullable NSURL *)url
+                                                   options:(SDWebImageDownloaderOptions)options
+                                                  progress:(nullable SDWebImageDownloaderProgressBlock)progressBlock
+                                                 completed:(nullable SDWebImageDownloaderCompletedBlock)completedBlock {
     __weak SDWebImageDownloader *wself = self;
     __weak SDWebImageDownloader *wself = self;
 
 
     return [self addProgressCallback:progressBlock completedBlock:completedBlock forURL:url createCallback:^SDWebImageDownloaderOperation *{
     return [self addProgressCallback:progressBlock completedBlock:completedBlock forURL:url createCallback:^SDWebImageDownloaderOperation *{
@@ -180,7 +180,7 @@
     }];
     }];
 }
 }
 
 
-- (void)cancel:(SDWebImageDownloadToken *)token {
+- (void)cancel:(nullable SDWebImageDownloadToken *)token {
     dispatch_barrier_async(self.barrierQueue, ^{
     dispatch_barrier_async(self.barrierQueue, ^{
         SDWebImageDownloaderOperation *operation = self.URLOperations[token.url];
         SDWebImageDownloaderOperation *operation = self.URLOperations[token.url];
         BOOL canceled = [operation cancel:token.downloadOperationCancelToken];
         BOOL canceled = [operation cancel:token.downloadOperationCancelToken];
@@ -190,10 +190,10 @@
     });
     });
 }
 }
 
 
-- (SDWebImageDownloadToken *)addProgressCallback:(SDWebImageDownloaderProgressBlock)progressBlock
-                                  completedBlock:(SDWebImageDownloaderCompletedBlock)completedBlock 
-                                          forURL:(NSURL *)url
-                                  createCallback:(SDWebImageDownloaderOperation *(^)())createCallback {
+- (nullable SDWebImageDownloadToken *)addProgressCallback:(SDWebImageDownloaderProgressBlock)progressBlock
+                                           completedBlock:(SDWebImageDownloaderCompletedBlock)completedBlock
+                                                   forURL:(nullable NSURL *)url
+                                           createCallback:(SDWebImageDownloaderOperation *(^)())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.
     // 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 (url == nil) {
         if (completedBlock != nil) {
         if (completedBlock != nil) {

@@ -10,22 +10,22 @@
 #import "SDWebImageDownloader.h"
 #import "SDWebImageDownloader.h"
 #import "SDWebImageOperation.h"
 #import "SDWebImageOperation.h"
 
 
-extern NSString *const SDWebImageDownloadStartNotification;
-extern NSString *const SDWebImageDownloadReceiveResponseNotification;
-extern NSString *const SDWebImageDownloadStopNotification;
-extern NSString *const SDWebImageDownloadFinishNotification;
+extern NSString * _Nonnull const SDWebImageDownloadStartNotification;
+extern NSString * _Nonnull const SDWebImageDownloadReceiveResponseNotification;
+extern NSString * _Nonnull const SDWebImageDownloadStopNotification;
+extern NSString * _Nonnull const SDWebImageDownloadFinishNotification;
 
 
 @interface SDWebImageDownloaderOperation : NSOperation <SDWebImageOperation, NSURLSessionTaskDelegate, NSURLSessionDataDelegate>
 @interface SDWebImageDownloaderOperation : NSOperation <SDWebImageOperation, NSURLSessionTaskDelegate, NSURLSessionDataDelegate>
 
 
 /**
 /**
  * The request used by the operation's task.
  * The request used by the operation's task.
  */
  */
-@property (strong, nonatomic, readonly) NSURLRequest *request;
+@property (strong, nonatomic, readonly, nullable) NSURLRequest *request;
 
 
 /**
 /**
  * The operation's task
  * The operation's task
  */
  */
-@property (strong, nonatomic, readonly) NSURLSessionTask *dataTask;
+@property (strong, nonatomic, readonly, nullable) NSURLSessionTask *dataTask;
 
 
 
 
 @property (assign, nonatomic) BOOL shouldDecompressImages;
 @property (assign, nonatomic) BOOL shouldDecompressImages;
@@ -41,7 +41,7 @@ extern NSString *const SDWebImageDownloadFinishNotification;
  *
  *
  * This will be overridden by any shared credentials that exist for the username or password of the request URL, if present.
  * This will be overridden by any shared credentials that exist for the username or password of the request URL, if present.
  */
  */
-@property (nonatomic, strong) NSURLCredential *credential;
+@property (nonatomic, strong, nullable) NSURLCredential *credential;
 
 
 /**
 /**
  * The SDWebImageDownloaderOptions for the receiver.
  * The SDWebImageDownloaderOptions for the receiver.
@@ -56,7 +56,7 @@ extern NSString *const SDWebImageDownloadFinishNotification;
 /**
 /**
  * The response returned by the operation's connection.
  * The response returned by the operation's connection.
  */
  */
-@property (strong, nonatomic) NSURLResponse *response;
+@property (strong, nonatomic, nullable) NSURLResponse *response;
 
 
 /**
 /**
  *  Initializes a `SDWebImageDownloaderOperation` object
  *  Initializes a `SDWebImageDownloaderOperation` object
@@ -69,9 +69,9 @@ extern NSString *const SDWebImageDownloadFinishNotification;
  *
  *
  *  @return the initialized instance
  *  @return the initialized instance
  */
  */
-- (instancetype)initWithRequest:(NSURLRequest *)request
-                      inSession:(NSURLSession *)session
-                        options:(SDWebImageDownloaderOptions)options NS_DESIGNATED_INITIALIZER;
+- (nonnull instancetype)initWithRequest:(nullable NSURLRequest *)request
+                              inSession:(nullable NSURLSession *)session
+                                options:(SDWebImageDownloaderOptions)options NS_DESIGNATED_INITIALIZER;
 
 
 /**
 /**
  *  Adds handlers for progress and completion. Returns a tokent that can be passed to -cancel: to cancel this set of
  *  Adds handlers for progress and completion. Returns a tokent that can be passed to -cancel: to cancel this set of
@@ -84,8 +84,8 @@ extern NSString *const SDWebImageDownloadFinishNotification;
  *
  *
  *  @return the token to use to cancel this set of handlers
  *  @return the token to use to cancel this set of handlers
  */
  */
-- (id)addHandlersForProgress:(SDWebImageDownloaderProgressBlock)progressBlock
-                   completed:(SDWebImageDownloaderCompletedBlock)completedBlock;
+- (nullable id)addHandlersForProgress:(nullable SDWebImageDownloaderProgressBlock)progressBlock
+                            completed:(nullable SDWebImageDownloaderCompletedBlock)completedBlock;
 
 
 /**
 /**
  *  Cancels a set of callbacks. Once all callbacks are canceled, the operation is cancelled.
  *  Cancels a set of callbacks. Once all callbacks are canceled, the operation is cancelled.
@@ -94,6 +94,6 @@ extern NSString *const SDWebImageDownloadFinishNotification;
  *
  *
  *  @return YES if the operation was stopped because this was the last token to be canceled. NO otherwise.
  *  @return YES if the operation was stopped because this was the last token to be canceled. NO otherwise.
  */
  */
-- (BOOL)cancel:(id)token;
+- (BOOL)cancel:(nullable id)token;
 
 
 @end
 @end

@@ -20,24 +20,26 @@ NSString *const SDWebImageDownloadFinishNotification = @"SDWebImageDownloadFinis
 static NSString *const kProgressCallbackKey = @"progress";
 static NSString *const kProgressCallbackKey = @"progress";
 static NSString *const kCompletedCallbackKey = @"completed";
 static NSString *const kCompletedCallbackKey = @"completed";
 
 
+typedef NSMutableDictionary<NSString *, id> SDCallbacksDictionary;
+
 @interface SDWebImageDownloaderOperation ()
 @interface SDWebImageDownloaderOperation ()
 
 
-@property (strong, nonatomic) NSMutableArray *callbackBlocks;
+@property (strong, nonatomic, nonnull) NSMutableArray<SDCallbacksDictionary *> *callbackBlocks;
 
 
 @property (assign, nonatomic, getter = isExecuting) BOOL executing;
 @property (assign, nonatomic, getter = isExecuting) BOOL executing;
 @property (assign, nonatomic, getter = isFinished) BOOL finished;
 @property (assign, nonatomic, getter = isFinished) BOOL finished;
-@property (strong, nonatomic) NSMutableData *imageData;
+@property (strong, nonatomic, nullable) NSMutableData *imageData;
 
 
 // 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
 // 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
 // the task associated with this operation
-@property (weak, nonatomic) NSURLSession *unownedSession;
+@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
 // This is set if we're using not using an injected NSURLSession. We're responsible of invalidating this one
-@property (strong, nonatomic) NSURLSession *ownedSession;
+@property (strong, nonatomic, nullable) NSURLSession *ownedSession;
 
 
-@property (strong, nonatomic, readwrite) NSURLSessionTask *dataTask;
+@property (strong, nonatomic, readwrite, nullable) NSURLSessionTask *dataTask;
 
 
-@property (strong, atomic) NSThread *thread;
-@property (SDDispatchQueueSetterSementics, nonatomic) dispatch_queue_t barrierQueue;
+@property (strong, atomic, nullable) NSThread *thread;
+@property (SDDispatchQueueSetterSementics, nonatomic, nullable) dispatch_queue_t barrierQueue;
 
 
 #if TARGET_OS_IPHONE && __IPHONE_OS_VERSION_MAX_ALLOWED >= __IPHONE_4_0
 #if TARGET_OS_IPHONE && __IPHONE_OS_VERSION_MAX_ALLOWED >= __IPHONE_4_0
 @property (assign, nonatomic) UIBackgroundTaskIdentifier backgroundTaskId;
 @property (assign, nonatomic) UIBackgroundTaskIdentifier backgroundTaskId;
@@ -54,13 +56,13 @@ static NSString *const kCompletedCallbackKey = @"completed";
 @synthesize executing = _executing;
 @synthesize executing = _executing;
 @synthesize finished = _finished;
 @synthesize finished = _finished;
 
 
-- (instancetype)init {
+- (nonnull instancetype)init {
     return [self initWithRequest:nil inSession:nil options:0];
     return [self initWithRequest:nil inSession:nil options:0];
 }
 }
 
 
-- (instancetype)initWithRequest:(NSURLRequest *)request
-                      inSession:(NSURLSession *)session
-                        options:(SDWebImageDownloaderOptions)options {
+- (nonnull instancetype)initWithRequest:(nullable NSURLRequest *)request
+                              inSession:(nullable NSURLSession *)session
+                                options:(SDWebImageDownloaderOptions)options {
     if ((self = [super init])) {
     if ((self = [super init])) {
         _request = request;
         _request = request;
         _shouldDecompressImages = YES;
         _shouldDecompressImages = YES;
@@ -80,9 +82,9 @@ static NSString *const kCompletedCallbackKey = @"completed";
     SDDispatchQueueRelease(_barrierQueue);
     SDDispatchQueueRelease(_barrierQueue);
 }
 }
 
 
-- (id)addHandlersForProgress:(SDWebImageDownloaderProgressBlock)progressBlock
-                   completed:(SDWebImageDownloaderCompletedBlock)completedBlock {
-    NSMutableDictionary *callbacks = [NSMutableDictionary new];
+- (nullable id)addHandlersForProgress:(nullable SDWebImageDownloaderProgressBlock)progressBlock
+                            completed:(nullable SDWebImageDownloaderCompletedBlock)completedBlock {
+    SDCallbacksDictionary *callbacks = [NSMutableDictionary new];
     if (progressBlock) callbacks[kProgressCallbackKey] = [progressBlock copy];
     if (progressBlock) callbacks[kProgressCallbackKey] = [progressBlock copy];
     if (completedBlock) callbacks[kCompletedCallbackKey] = [completedBlock copy];
     if (completedBlock) callbacks[kCompletedCallbackKey] = [completedBlock copy];
     dispatch_barrier_async(self.barrierQueue, ^{
     dispatch_barrier_async(self.barrierQueue, ^{
@@ -91,8 +93,8 @@ static NSString *const kCompletedCallbackKey = @"completed";
     return callbacks;
     return callbacks;
 }
 }
 
 
-- (NSArray *)callbacksForKey:(NSString *)key {
-    __block NSMutableArray *callbacks = nil;
+- (nullable NSArray<id> *)callbacksForKey:(NSString *)key {
+    __block NSMutableArray<id> *callbacks = nil;
     dispatch_sync(self.barrierQueue, ^{
     dispatch_sync(self.barrierQueue, ^{
         // We need to remove [NSNull null] because there might not always be a progress block for each callback
         // We need to remove [NSNull null] because there might not always be a progress block for each callback
         callbacks = [[self.callbackBlocks valueForKey:key] mutableCopy];
         callbacks = [[self.callbackBlocks valueForKey:key] mutableCopy];
@@ -101,7 +103,7 @@ static NSString *const kCompletedCallbackKey = @"completed";
     return callbacks;
     return callbacks;
 }
 }
 
 
-- (BOOL)cancel:(id)token {
+- (BOOL)cancel:(nullable id)token {
     __block BOOL shouldCancel = NO;
     __block BOOL shouldCancel = NO;
     dispatch_barrier_sync(self.barrierQueue, ^{
     dispatch_barrier_sync(self.barrierQueue, ^{
         [self.callbackBlocks removeObjectIdenticalTo:token];
         [self.callbackBlocks removeObjectIdenticalTo:token];
@@ -410,7 +412,7 @@ didReceiveResponse:(NSURLResponse *)response
 #pragma mark NSURLSessionTaskDelegate
 #pragma mark NSURLSessionTaskDelegate
 
 
 - (void)URLSession:(NSURLSession *)session task:(NSURLSessionTask *)task didCompleteWithError:(NSError *)error {
 - (void)URLSession:(NSURLSession *)session task:(NSURLSessionTask *)task didCompleteWithError:(NSError *)error {
-    NSArray *completionBlocks = [[self callbacksForKey:kCompletedCallbackKey] copy];
+    NSArray<id> *completionBlocks = [[self callbacksForKey:kCompletedCallbackKey] copy];
     @synchronized(self) {
     @synchronized(self) {
         self.thread = nil;
         self.thread = nil;
         self.dataTask = nil;
         self.dataTask = nil;
@@ -521,7 +523,7 @@ didReceiveResponse:(NSURLResponse *)response
     }
     }
 }
 }
 
 
-- (UIImage *)scaledImageForKey:(NSString *)key image:(UIImage *)image {
+- (nullable UIImage *)scaledImageForKey:(nullable NSString *)key image:(nullable UIImage *)image {
     return SDScaledImageForKey(key, image);
     return SDScaledImageForKey(key, image);
 }
 }
 
 

@@ -90,11 +90,11 @@ typedef NS_OPTIONS(NSUInteger, SDWebImageOptions) {
     SDWebImageAvoidAutoSetImage = 1 << 11
     SDWebImageAvoidAutoSetImage = 1 << 11
 };
 };
 
 
-typedef void(^SDExternalCompletionBlock)(UIImage *image, NSError *error, SDImageCacheType cacheType, NSURL *imageURL);
+typedef void(^SDExternalCompletionBlock)(UIImage * _Nullable image, NSError * _Nullable error, SDImageCacheType cacheType, NSURL * _Nullable imageURL);
 
 
-typedef void(^SDInternalCompletionBlock)(UIImage *image, NSData *data, NSError *error, SDImageCacheType cacheType, BOOL finished, NSURL *imageURL);
+typedef void(^SDInternalCompletionBlock)(UIImage * _Nullable image, NSData * _Nullable data, NSError * _Nullable error, SDImageCacheType cacheType, BOOL finished, NSURL * _Nullable imageURL);
 
 
-typedef NSString *(^SDWebImageCacheKeyFilterBlock)(NSURL *url);
+typedef NSString * _Nullable (^SDWebImageCacheKeyFilterBlock)(NSURL * _Nullable url);
 
 
 
 
 @class SDWebImageManager;
 @class SDWebImageManager;
@@ -111,7 +111,7 @@ typedef NSString *(^SDWebImageCacheKeyFilterBlock)(NSURL *url);
  *
  *
  * @return Return NO to prevent the downloading of the image on cache misses. If not implemented, YES is implied.
  * @return Return NO to prevent the downloading of the image on cache misses. If not implemented, YES is implied.
  */
  */
-- (BOOL)imageManager:(SDWebImageManager *)imageManager shouldDownloadImageForURL:(NSURL *)imageURL;
+- (BOOL)imageManager:(nonnull SDWebImageManager *)imageManager shouldDownloadImageForURL:(nullable NSURL *)imageURL;
 
 
 /**
 /**
  * Allows to transform the image immediately after it has been downloaded and just before to cache it on disk and memory.
  * Allows to transform the image immediately after it has been downloaded and just before to cache it on disk and memory.
@@ -123,7 +123,7 @@ typedef NSString *(^SDWebImageCacheKeyFilterBlock)(NSURL *url);
  *
  *
  * @return The transformed image object.
  * @return The transformed image object.
  */
  */
-- (UIImage *)imageManager:(SDWebImageManager *)imageManager transformDownloadedImage:(UIImage *)image withURL:(NSURL *)imageURL;
+- (nullable UIImage *)imageManager:(nonnull SDWebImageManager *)imageManager transformDownloadedImage:(nullable UIImage *)image withURL:(nullable NSURL *)imageURL;
 
 
 @end
 @end
 
 
@@ -151,10 +151,10 @@ SDWebImageManager *manager = [SDWebImageManager sharedManager];
  */
  */
 @interface SDWebImageManager : NSObject
 @interface SDWebImageManager : NSObject
 
 
-@property (weak, nonatomic) id <SDWebImageManagerDelegate> delegate;
+@property (weak, nonatomic, nullable) id <SDWebImageManagerDelegate> delegate;
 
 
-@property (strong, nonatomic, readonly) SDImageCache *imageCache;
-@property (strong, nonatomic, readonly) SDWebImageDownloader *imageDownloader;
+@property (strong, nonatomic, readonly, nullable) SDImageCache *imageCache;
+@property (strong, nonatomic, readonly, nullable) SDWebImageDownloader *imageDownloader;
 
 
 /**
 /**
  * The cache filter is a block used each time SDWebImageManager need to convert an URL into a cache key. This can
  * The cache filter is a block used each time SDWebImageManager need to convert an URL into a cache key. This can
@@ -172,20 +172,20 @@ SDWebImageManager *manager = [SDWebImageManager sharedManager];
 
 
  * @endcode
  * @endcode
  */
  */
-@property (nonatomic, copy) SDWebImageCacheKeyFilterBlock cacheKeyFilter;
+@property (nonatomic, copy, nullable) SDWebImageCacheKeyFilterBlock cacheKeyFilter;
 
 
 /**
 /**
  * Returns global SDWebImageManager instance.
  * Returns global SDWebImageManager instance.
  *
  *
  * @return SDWebImageManager shared instance
  * @return SDWebImageManager shared instance
  */
  */
-+ (SDWebImageManager *)sharedManager;
++ (nonnull SDWebImageManager *)sharedManager;
 
 
 /**
 /**
  * Allows to specify instance of cache and image downloader used with image manager.
  * Allows to specify instance of cache and image downloader used with image manager.
  * @return new instance of `SDWebImageManager` with specified cache and downloader.
  * @return new instance of `SDWebImageManager` with specified cache and downloader.
  */
  */
-- (instancetype)initWithCache:(SDImageCache *)cache downloader:(SDWebImageDownloader *)downloader;
+- (nonnull instancetype)initWithCache:(nonnull SDImageCache *)cache downloader:(nonnull SDWebImageDownloader *)downloader;
 
 
 /**
 /**
  * Downloads the image at the given URL if not present in cache or return the cached version otherwise.
  * Downloads the image at the given URL if not present in cache or return the cached version otherwise.
@@ -211,10 +211,10 @@ SDWebImageManager *manager = [SDWebImageManager sharedManager];
  *
  *
  * @return Returns an NSObject conforming to SDWebImageOperation. Should be an instance of SDWebImageDownloaderOperation
  * @return Returns an NSObject conforming to SDWebImageOperation. Should be an instance of SDWebImageDownloaderOperation
  */
  */
-- (id <SDWebImageOperation>)loadImageWithURL:(NSURL *)url
-                                     options:(SDWebImageOptions)options
-                                    progress:(SDWebImageDownloaderProgressBlock)progressBlock
-                                   completed:(SDInternalCompletionBlock)completedBlock;
+- (nullable id <SDWebImageOperation>)loadImageWithURL:(nullable NSURL *)url
+                                              options:(SDWebImageOptions)options
+                                             progress:(nullable SDWebImageDownloaderProgressBlock)progressBlock
+                                            completed:(nullable SDInternalCompletionBlock)completedBlock;
 
 
 /**
 /**
  * Saves image to cache for given URL
  * Saves image to cache for given URL
@@ -224,7 +224,7 @@ SDWebImageManager *manager = [SDWebImageManager sharedManager];
  *
  *
  */
  */
 
 
-- (void)saveImageToCache:(UIImage *)image forURL:(NSURL *)url;
+- (void)saveImageToCache:(nullable UIImage *)image forURL:(nullable NSURL *)url;
 
 
 /**
 /**
  * Cancel all current operations
  * Cancel all current operations
@@ -243,7 +243,7 @@ SDWebImageManager *manager = [SDWebImageManager sharedManager];
  *
  *
  *  @return if the image was already cached
  *  @return if the image was already cached
  */
  */
-- (BOOL)cachedImageExistsForURL:(NSURL *)url;
+- (BOOL)cachedImageExistsForURL:(nullable NSURL *)url;
 
 
 /**
 /**
  *  Check if image has already been cached on disk only
  *  Check if image has already been cached on disk only
@@ -252,7 +252,7 @@ SDWebImageManager *manager = [SDWebImageManager sharedManager];
  *
  *
  *  @return if the image was already cached (disk only)
  *  @return if the image was already cached (disk only)
  */
  */
-- (BOOL)diskImageExistsForURL:(NSURL *)url;
+- (BOOL)diskImageExistsForURL:(nullable NSURL *)url;
 
 
 /**
 /**
  *  Async check if image has already been cached
  *  Async check if image has already been cached
@@ -262,8 +262,8 @@ SDWebImageManager *manager = [SDWebImageManager sharedManager];
  *  
  *  
  *  @note the completion block is always executed on the main queue
  *  @note the completion block is always executed on the main queue
  */
  */
-- (void)cachedImageExistsForURL:(NSURL *)url
-                     completion:(SDWebImageCheckCacheCompletionBlock)completionBlock;
+- (void)cachedImageExistsForURL:(nullable NSURL *)url
+                     completion:(nullable SDWebImageCheckCacheCompletionBlock)completionBlock;
 
 
 /**
 /**
  *  Async check if image has already been cached on disk only
  *  Async check if image has already been cached on disk only
@@ -273,13 +273,13 @@ SDWebImageManager *manager = [SDWebImageManager sharedManager];
  *
  *
  *  @note the completion block is always executed on the main queue
  *  @note the completion block is always executed on the main queue
  */
  */
-- (void)diskImageExistsForURL:(NSURL *)url
-                   completion:(SDWebImageCheckCacheCompletionBlock)completionBlock;
+- (void)diskImageExistsForURL:(nullable NSURL *)url
+                   completion:(nullable SDWebImageCheckCacheCompletionBlock)completionBlock;
 
 
 
 
 /**
 /**
  *Return the cache key for a given URL
  *Return the cache key for a given URL
  */
  */
-- (NSString *)cacheKeyForURL:(NSURL *)url;
+- (nullable NSString *)cacheKeyForURL:(nullable NSURL *)url;
 
 
 @end
 @end

@@ -12,23 +12,23 @@
 @interface SDWebImageCombinedOperation : NSObject <SDWebImageOperation>
 @interface SDWebImageCombinedOperation : NSObject <SDWebImageOperation>
 
 
 @property (assign, nonatomic, getter = isCancelled) BOOL cancelled;
 @property (assign, nonatomic, getter = isCancelled) BOOL cancelled;
-@property (copy, nonatomic) SDWebImageNoParamsBlock cancelBlock;
-@property (strong, nonatomic) NSOperation *cacheOperation;
+@property (copy, nonatomic, nullable) SDWebImageNoParamsBlock cancelBlock;
+@property (strong, nonatomic, nullable) NSOperation *cacheOperation;
 
 
 @end
 @end
 
 
 @interface SDWebImageManager ()
 @interface SDWebImageManager ()
 
 
-@property (strong, nonatomic, readwrite) SDImageCache *imageCache;
-@property (strong, nonatomic, readwrite) SDWebImageDownloader *imageDownloader;
-@property (strong, nonatomic) NSMutableSet *failedURLs;
-@property (strong, nonatomic) NSMutableArray *runningOperations;
+@property (strong, nonatomic, readwrite, nonnull) SDImageCache *imageCache;
+@property (strong, nonatomic, readwrite, nonnull) SDWebImageDownloader *imageDownloader;
+@property (strong, nonatomic, nonnull) NSMutableSet<NSURL *> *failedURLs;
+@property (strong, nonatomic, nonnull) NSMutableArray<SDWebImageCombinedOperation *> *runningOperations;
 
 
 @end
 @end
 
 
 @implementation SDWebImageManager
 @implementation SDWebImageManager
 
 
-+ (SDWebImageManager*)sharedManager {
++ (nonnull SDWebImageManager*)sharedManager {
     static dispatch_once_t once;
     static dispatch_once_t once;
     static id instance;
     static id instance;
     dispatch_once(&once, ^{
     dispatch_once(&once, ^{
@@ -37,13 +37,13 @@
     return instance;
     return instance;
 }
 }
 
 
-- (instancetype)init {
+- (nonnull instancetype)init {
     SDImageCache *cache = [SDImageCache sharedImageCache];
     SDImageCache *cache = [SDImageCache sharedImageCache];
     SDWebImageDownloader *downloader = [SDWebImageDownloader sharedDownloader];
     SDWebImageDownloader *downloader = [SDWebImageDownloader sharedDownloader];
     return [self initWithCache:cache downloader:downloader];
     return [self initWithCache:cache downloader:downloader];
 }
 }
 
 
-- (instancetype)initWithCache:(SDImageCache *)cache downloader:(SDWebImageDownloader *)downloader {
+- (nonnull instancetype)initWithCache:(nonnull SDImageCache *)cache downloader:(nonnull SDWebImageDownloader *)downloader {
     if ((self = [super init])) {
     if ((self = [super init])) {
         _imageCache = cache;
         _imageCache = cache;
         _imageDownloader = downloader;
         _imageDownloader = downloader;
@@ -53,37 +53,31 @@
     return self;
     return self;
 }
 }
 
 
-- (NSString *)cacheKeyForURL:(NSURL *)url {
+- (nullable NSString *)cacheKeyForURL:(nullable NSURL *)url {
     if (!url) {
     if (!url) {
         return @"";
         return @"";
     }
     }
-    
+
     if (self.cacheKeyFilter) {
     if (self.cacheKeyFilter) {
         return self.cacheKeyFilter(url);
         return self.cacheKeyFilter(url);
     } else {
     } else {
-        if (NSClassFromString(@"NSURLComponents") && [NSURLComponents instancesRespondToSelector:@selector(string)]) {
-            NSURLComponents *urlComponents = [[NSURLComponents alloc] initWithURL:url resolvingAgainstBaseURL:NO];
-            urlComponents.query = nil; // Strip out query parameters.
-            return urlComponents.URL.absoluteString;
-        } else {
-            return url.absoluteString;
-        }
+        return url.absoluteString;
     }
     }
 }
 }
 
 
-- (BOOL)cachedImageExistsForURL:(NSURL *)url {
+- (BOOL)cachedImageExistsForURL:(nullable NSURL *)url {
     NSString *key = [self cacheKeyForURL:url];
     NSString *key = [self cacheKeyForURL:url];
     if ([self.imageCache imageFromMemoryCacheForKey:key] != nil) return YES;
     if ([self.imageCache imageFromMemoryCacheForKey:key] != nil) return YES;
     return [self.imageCache diskImageExistsWithKey:key];
     return [self.imageCache diskImageExistsWithKey:key];
 }
 }
 
 
-- (BOOL)diskImageExistsForURL:(NSURL *)url {
+- (BOOL)diskImageExistsForURL:(nullable NSURL *)url {
     NSString *key = [self cacheKeyForURL:url];
     NSString *key = [self cacheKeyForURL:url];
     return [self.imageCache diskImageExistsWithKey:key];
     return [self.imageCache diskImageExistsWithKey:key];
 }
 }
 
 
-- (void)cachedImageExistsForURL:(NSURL *)url
-                     completion:(SDWebImageCheckCacheCompletionBlock)completionBlock {
+- (void)cachedImageExistsForURL:(nullable NSURL *)url
+                     completion:(nullable SDWebImageCheckCacheCompletionBlock)completionBlock {
     NSString *key = [self cacheKeyForURL:url];
     NSString *key = [self cacheKeyForURL:url];
     
     
     BOOL isInMemoryCache = ([self.imageCache imageFromMemoryCacheForKey:key] != nil);
     BOOL isInMemoryCache = ([self.imageCache imageFromMemoryCacheForKey:key] != nil);
@@ -106,8 +100,8 @@
     }];
     }];
 }
 }
 
 
-- (void)diskImageExistsForURL:(NSURL *)url
-                   completion:(SDWebImageCheckCacheCompletionBlock)completionBlock {
+- (void)diskImageExistsForURL:(nullable NSURL *)url
+                   completion:(nullable SDWebImageCheckCacheCompletionBlock)completionBlock {
     NSString *key = [self cacheKeyForURL:url];
     NSString *key = [self cacheKeyForURL:url];
     
     
     [self.imageCache diskImageExistsWithKey:key completion:^(BOOL isInDiskCache) {
     [self.imageCache diskImageExistsWithKey:key completion:^(BOOL isInDiskCache) {
@@ -118,10 +112,10 @@
     }];
     }];
 }
 }
 
 
-- (id <SDWebImageOperation>)loadImageWithURL:(NSURL *)url
+- (id <SDWebImageOperation>)loadImageWithURL:(nullable NSURL *)url
                                      options:(SDWebImageOptions)options
                                      options:(SDWebImageOptions)options
-                                    progress:(SDWebImageDownloaderProgressBlock)progressBlock
-                                   completed:(SDInternalCompletionBlock)completedBlock {
+                                    progress:(nullable SDWebImageDownloaderProgressBlock)progressBlock
+                                   completed:(nullable SDInternalCompletionBlock)completedBlock {
     // Invoking this method without a completedBlock is pointless
     // Invoking this method without a completedBlock is pointless
     NSAssert(completedBlock != nil, @"If you mean to prefetch the image, use -[SDWebImagePrefetcher prefetchURLs] instead");
     NSAssert(completedBlock != nil, @"If you mean to prefetch the image, use -[SDWebImagePrefetcher prefetchURLs] instead");
 
 
@@ -140,8 +134,10 @@
     __weak SDWebImageCombinedOperation *weakOperation = operation;
     __weak SDWebImageCombinedOperation *weakOperation = operation;
 
 
     BOOL isFailedUrl = NO;
     BOOL isFailedUrl = NO;
-    @synchronized (self.failedURLs) {
-        isFailedUrl = [self.failedURLs containsObject:url];
+    if (url) {
+        @synchronized (self.failedURLs) {
+            isFailedUrl = [self.failedURLs containsObject:url];
+        }
     }
     }
 
 
     if (url.absoluteString.length == 0 || (!(options & SDWebImageRetryFailed) && isFailedUrl)) {
     if (url.absoluteString.length == 0 || (!(options & SDWebImageRetryFailed) && isFailedUrl)) {
@@ -299,7 +295,7 @@
     return operation;
     return operation;
 }
 }
 
 
-- (void)saveImageToCache:(UIImage *)image forURL:(NSURL *)url {
+- (void)saveImageToCache:(nullable UIImage *)image forURL:(nullable NSURL *)url {
     if (image && url) {
     if (image && url) {
         NSString *key = [self cacheKeyForURL:url];
         NSString *key = [self cacheKeyForURL:url];
         [self.imageCache storeImage:image forKey:key toDisk:YES];
         [self.imageCache storeImage:image forKey:key toDisk:YES];
@@ -308,7 +304,7 @@
 
 
 - (void)cancelAll {
 - (void)cancelAll {
     @synchronized (self.runningOperations) {
     @synchronized (self.runningOperations) {
-        NSArray *copiedOperations = [self.runningOperations copy];
+        NSArray<SDWebImageCombinedOperation *> *copiedOperations = [self.runningOperations copy];
         [copiedOperations makeObjectsPerformSelector:@selector(cancel)];
         [copiedOperations makeObjectsPerformSelector:@selector(cancel)];
         [self.runningOperations removeObjectsInArray:copiedOperations];
         [self.runningOperations removeObjectsInArray:copiedOperations];
     }
     }
@@ -327,7 +323,7 @@
 
 
 @implementation SDWebImageCombinedOperation
 @implementation SDWebImageCombinedOperation
 
 
-- (void)setCancelBlock:(SDWebImageNoParamsBlock)cancelBlock {
+- (void)setCancelBlock:(nullable SDWebImageNoParamsBlock)cancelBlock {
     // check if the operation is already cancelled, then we just call the cancelBlock
     // check if the operation is already cancelled, then we just call the cancelBlock
     if (self.isCancelled) {
     if (self.isCancelled) {
         if (cancelBlock) {
         if (cancelBlock) {

@@ -23,7 +23,7 @@
  * @param finishedCount   The total number of images that were prefetched (successful or not)
  * @param finishedCount   The total number of images that were prefetched (successful or not)
  * @param totalCount      The total number of images that were to be prefetched
  * @param totalCount      The total number of images that were to be prefetched
  */
  */
-- (void)imagePrefetcher:(SDWebImagePrefetcher *)imagePrefetcher didPrefetchURL:(NSURL *)imageURL finishedCount:(NSUInteger)finishedCount totalCount:(NSUInteger)totalCount;
+- (void)imagePrefetcher:(nonnull SDWebImagePrefetcher *)imagePrefetcher didPrefetchURL:(nullable NSURL *)imageURL finishedCount:(NSUInteger)finishedCount totalCount:(NSUInteger)totalCount;
 
 
 /**
 /**
  * Called when all images are prefetched.
  * Called when all images are prefetched.
@@ -31,7 +31,7 @@
  * @param totalCount      The total number of images that were prefetched (whether successful or not)
  * @param totalCount      The total number of images that were prefetched (whether successful or not)
  * @param skippedCount    The total number of images that were skipped
  * @param skippedCount    The total number of images that were skipped
  */
  */
-- (void)imagePrefetcher:(SDWebImagePrefetcher *)imagePrefetcher didFinishWithTotalCount:(NSUInteger)totalCount skippedCount:(NSUInteger)skippedCount;
+- (void)imagePrefetcher:(nonnull SDWebImagePrefetcher *)imagePrefetcher didFinishWithTotalCount:(NSUInteger)totalCount skippedCount:(NSUInteger)skippedCount;
 
 
 @end
 @end
 
 
@@ -46,7 +46,7 @@ typedef void(^SDWebImagePrefetcherCompletionBlock)(NSUInteger noOfFinishedUrls,
 /**
 /**
  *  The web image manager
  *  The web image manager
  */
  */
-@property (strong, nonatomic, readonly) SDWebImageManager *manager;
+@property (strong, nonatomic, readonly, nonnull) SDWebImageManager *manager;
 
 
 /**
 /**
  * Maximum number of URLs to prefetch at the same time. Defaults to 3.
  * Maximum number of URLs to prefetch at the same time. Defaults to 3.
@@ -61,19 +61,19 @@ typedef void(^SDWebImagePrefetcherCompletionBlock)(NSUInteger noOfFinishedUrls,
 /**
 /**
  * Queue options for Prefetcher. Defaults to Main Queue.
  * Queue options for Prefetcher. Defaults to Main Queue.
  */
  */
-@property (nonatomic, assign) dispatch_queue_t prefetcherQueue;
+@property (nonatomic, assign, nonnull) dispatch_queue_t prefetcherQueue;
 
 
-@property (weak, nonatomic) id <SDWebImagePrefetcherDelegate> delegate;
+@property (weak, nonatomic, nullable) id <SDWebImagePrefetcherDelegate> delegate;
 
 
 /**
 /**
  * Return the global image prefetcher instance.
  * Return the global image prefetcher instance.
  */
  */
-+ (SDWebImagePrefetcher *)sharedImagePrefetcher;
++ (nonnull SDWebImagePrefetcher *)sharedImagePrefetcher;
 
 
 /**
 /**
  * Allows you to instantiate a prefetcher with any arbitrary image manager.
  * Allows you to instantiate a prefetcher with any arbitrary image manager.
  */
  */
-- (instancetype)initWithImageManager:(SDWebImageManager *)manager NS_DESIGNATED_INITIALIZER;
+- (nonnull instancetype)initWithImageManager:(nonnull SDWebImageManager *)manager NS_DESIGNATED_INITIALIZER;
 
 
 /**
 /**
  * Assign list of URLs to let SDWebImagePrefetcher to queue the prefetching,
  * Assign list of URLs to let SDWebImagePrefetcher to queue the prefetching,
@@ -82,7 +82,7 @@ typedef void(^SDWebImagePrefetcherCompletionBlock)(NSUInteger noOfFinishedUrls,
  *
  *
  * @param urls list of URLs to prefetch
  * @param urls list of URLs to prefetch
  */
  */
-- (void)prefetchURLs:(NSArray *)urls;
+- (void)prefetchURLs:(nullable NSArray<NSURL *> *)urls;
 
 
 /**
 /**
  * Assign list of URLs to let SDWebImagePrefetcher to queue the prefetching,
  * Assign list of URLs to let SDWebImagePrefetcher to queue the prefetching,
@@ -97,7 +97,9 @@ typedef void(^SDWebImagePrefetcherCompletionBlock)(NSUInteger noOfFinishedUrls,
  *                        first param is the number of completed (successful or not) requests,
  *                        first param is the number of completed (successful or not) requests,
  *                        second parameter is the number of skipped requests
  *                        second parameter is the number of skipped requests
  */
  */
-- (void)prefetchURLs:(NSArray *)urls progress:(SDWebImagePrefetcherProgressBlock)progressBlock completed:(SDWebImagePrefetcherCompletionBlock)completionBlock;
+- (void)prefetchURLs:(nullable NSArray<NSURL *> *)urls
+            progress:(nullable SDWebImagePrefetcherProgressBlock)progressBlock
+           completed:(nullable SDWebImagePrefetcherCompletionBlock)completionBlock;
 
 
 /**
 /**
  * Remove and cancel queued list
  * Remove and cancel queued list

@@ -10,20 +10,20 @@
 
 
 @interface SDWebImagePrefetcher ()
 @interface SDWebImagePrefetcher ()
 
 
-@property (strong, nonatomic) SDWebImageManager *manager;
-@property (strong, nonatomic) NSArray *prefetchURLs;
+@property (strong, nonatomic, nonnull) SDWebImageManager *manager;
+@property (strong, nonatomic, nullable) NSArray<NSURL *> *prefetchURLs;
 @property (assign, nonatomic) NSUInteger requestedCount;
 @property (assign, nonatomic) NSUInteger requestedCount;
 @property (assign, nonatomic) NSUInteger skippedCount;
 @property (assign, nonatomic) NSUInteger skippedCount;
 @property (assign, nonatomic) NSUInteger finishedCount;
 @property (assign, nonatomic) NSUInteger finishedCount;
 @property (assign, nonatomic) NSTimeInterval startedTime;
 @property (assign, nonatomic) NSTimeInterval startedTime;
-@property (copy, nonatomic) SDWebImagePrefetcherCompletionBlock completionBlock;
-@property (copy, nonatomic) SDWebImagePrefetcherProgressBlock progressBlock;
+@property (copy, nonatomic, nullable) SDWebImagePrefetcherCompletionBlock completionBlock;
+@property (copy, nonatomic, nullable) SDWebImagePrefetcherProgressBlock progressBlock;
 
 
 @end
 @end
 
 
 @implementation SDWebImagePrefetcher
 @implementation SDWebImagePrefetcher
 
 
-+ (SDWebImagePrefetcher *)sharedImagePrefetcher {
++ (nonnull SDWebImagePrefetcher *)sharedImagePrefetcher {
     static dispatch_once_t once;
     static dispatch_once_t once;
     static id instance;
     static id instance;
     dispatch_once(&once, ^{
     dispatch_once(&once, ^{
@@ -32,11 +32,11 @@
     return instance;
     return instance;
 }
 }
 
 
-- (instancetype)init {
+- (nonnull instancetype)init {
     return [self initWithImageManager:[SDWebImageManager new]];
     return [self initWithImageManager:[SDWebImageManager new]];
 }
 }
 
 
-- (instancetype)initWithImageManager:(SDWebImageManager *)manager {
+- (nonnull instancetype)initWithImageManager:(SDWebImageManager *)manager {
     if ((self = [super init])) {
     if ((self = [super init])) {
         _manager = manager;
         _manager = manager;
         _options = SDWebImageLowPriority;
         _options = SDWebImageLowPriority;
@@ -105,11 +105,13 @@
     }
     }
 }
 }
 
 
-- (void)prefetchURLs:(NSArray *)urls {
+- (void)prefetchURLs:(nullable NSArray<NSURL *> *)urls {
     [self prefetchURLs:urls progress:nil completed:nil];
     [self prefetchURLs:urls progress:nil completed:nil];
 }
 }
 
 
-- (void)prefetchURLs:(NSArray *)urls progress:(SDWebImagePrefetcherProgressBlock)progressBlock completed:(SDWebImagePrefetcherCompletionBlock)completionBlock {
+- (void)prefetchURLs:(nullable NSArray<NSURL *> *)urls
+            progress:(nullable SDWebImagePrefetcherProgressBlock)progressBlock
+           completed:(nullable SDWebImagePrefetcherCompletionBlock)completionBlock {
     [self cancelPrefetching]; // Prevent duplicate prefetch request
     [self cancelPrefetching]; // Prevent duplicate prefetch request
     self.startedTime = CFAbsoluteTimeGetCurrent();
     self.startedTime = CFAbsoluteTimeGetCurrent();
     self.prefetchURLs = urls;
     self.prefetchURLs = urls;

@@ -17,14 +17,14 @@
 /**
 /**
  * Get the current image URL.
  * Get the current image URL.
  */
  */
-- (NSURL *)sd_currentImageURL;
+- (nullable NSURL *)sd_currentImageURL;
 
 
 /**
 /**
  * Get the image URL for a control state.
  * Get the image URL for a control state.
  * 
  * 
  * @param state Which state you want to know the URL for. The values are described in UIControlState.
  * @param state Which state you want to know the URL for. The values are described in UIControlState.
  */
  */
-- (NSURL *)sd_imageURLForState:(UIControlState)state;
+- (nullable NSURL *)sd_imageURLForState:(UIControlState)state;
 
 
 /**
 /**
  * Set the imageView `image` with an `url`.
  * Set the imageView `image` with an `url`.
@@ -34,7 +34,8 @@
  * @param url   The url for the image.
  * @param url   The url for the image.
  * @param state The state that uses the specified title. The values are described in UIControlState.
  * @param state The state that uses the specified title. The values are described in UIControlState.
  */
  */
-- (void)sd_setImageWithURL:(NSURL *)url forState:(UIControlState)state;
+- (void)sd_setImageWithURL:(nullable NSURL *)url
+                  forState:(UIControlState)state;
 
 
 /**
 /**
  * Set the imageView `image` with an `url` and a placeholder.
  * Set the imageView `image` with an `url` and a placeholder.
@@ -46,7 +47,9 @@
  * @param placeholder The image to be set initially, until the image request finishes.
  * @param placeholder The image to be set initially, until the image request finishes.
  * @see sd_setImageWithURL:placeholderImage:options:
  * @see sd_setImageWithURL:placeholderImage:options:
  */
  */
-- (void)sd_setImageWithURL:(NSURL *)url forState:(UIControlState)state placeholderImage:(UIImage *)placeholder;
+- (void)sd_setImageWithURL:(nullable NSURL *)url
+                  forState:(UIControlState)state
+          placeholderImage:(nullable UIImage *)placeholder;
 
 
 /**
 /**
  * Set the imageView `image` with an `url`, placeholder and custom options.
  * Set the imageView `image` with an `url`, placeholder and custom options.
@@ -58,7 +61,10 @@
  * @param placeholder The image to be set initially, until the image request finishes.
  * @param placeholder The image to be set initially, until the image request finishes.
  * @param options     The options to use when downloading the image. @see SDWebImageOptions for the possible values.
  * @param options     The options to use when downloading the image. @see SDWebImageOptions for the possible values.
  */
  */
-- (void)sd_setImageWithURL:(NSURL *)url forState:(UIControlState)state placeholderImage:(UIImage *)placeholder options:(SDWebImageOptions)options;
+- (void)sd_setImageWithURL:(nullable NSURL *)url
+                  forState:(UIControlState)state
+          placeholderImage:(nullable UIImage *)placeholder
+                   options:(SDWebImageOptions)options;
 
 
 /**
 /**
  * Set the imageView `image` with an `url`.
  * Set the imageView `image` with an `url`.
@@ -73,7 +79,9 @@
  *                       indicating if the image was retrieved from the local cache or from the network.
  *                       indicating if the image was retrieved from the local cache or from the network.
  *                       The fourth parameter is the original image url.
  *                       The fourth parameter is the original image url.
  */
  */
-- (void)sd_setImageWithURL:(NSURL *)url forState:(UIControlState)state completed:(SDExternalCompletionBlock)completedBlock;
+- (void)sd_setImageWithURL:(nullable NSURL *)url
+                  forState:(UIControlState)state
+                 completed:(nullable SDExternalCompletionBlock)completedBlock;
 
 
 /**
 /**
  * Set the imageView `image` with an `url`, placeholder.
  * Set the imageView `image` with an `url`, placeholder.
@@ -89,7 +97,10 @@
  *                       indicating if the image was retrieved from the local cache or from the network.
  *                       indicating if the image was retrieved from the local cache or from the network.
  *                       The fourth parameter is the original image url.
  *                       The fourth parameter is the original image url.
  */
  */
-- (void)sd_setImageWithURL:(NSURL *)url forState:(UIControlState)state placeholderImage:(UIImage *)placeholder completed:(SDExternalCompletionBlock)completedBlock;
+- (void)sd_setImageWithURL:(nullable NSURL *)url
+                  forState:(UIControlState)state
+          placeholderImage:(nullable UIImage *)placeholder
+                 completed:(nullable SDExternalCompletionBlock)completedBlock;
 
 
 /**
 /**
  * Set the imageView `image` with an `url`, placeholder and custom options.
  * Set the imageView `image` with an `url`, placeholder and custom options.
@@ -106,7 +117,11 @@
  *                       indicating if the image was retrieved from the local cache or from the network.
  *                       indicating if the image was retrieved from the local cache or from the network.
  *                       The fourth parameter is the original image url.
  *                       The fourth parameter is the original image url.
  */
  */
-- (void)sd_setImageWithURL:(NSURL *)url forState:(UIControlState)state placeholderImage:(UIImage *)placeholder options:(SDWebImageOptions)options completed:(SDExternalCompletionBlock)completedBlock;
+- (void)sd_setImageWithURL:(nullable NSURL *)url
+                  forState:(UIControlState)state
+          placeholderImage:(nullable UIImage *)placeholder
+                   options:(SDWebImageOptions)options
+                 completed:(nullable SDExternalCompletionBlock)completedBlock;
 
 
 /**
 /**
  * Set the backgroundImageView `image` with an `url`.
  * Set the backgroundImageView `image` with an `url`.
@@ -116,7 +131,8 @@
  * @param url   The url for the image.
  * @param url   The url for the image.
  * @param state The state that uses the specified title. The values are described in UIControlState.
  * @param state The state that uses the specified title. The values are described in UIControlState.
  */
  */
-- (void)sd_setBackgroundImageWithURL:(NSURL *)url forState:(UIControlState)state;
+- (void)sd_setBackgroundImageWithURL:(nullable NSURL *)url
+                            forState:(UIControlState)state;
 
 
 /**
 /**
  * Set the backgroundImageView `image` with an `url` and a placeholder.
  * Set the backgroundImageView `image` with an `url` and a placeholder.
@@ -128,7 +144,9 @@
  * @param placeholder The image to be set initially, until the image request finishes.
  * @param placeholder The image to be set initially, until the image request finishes.
  * @see sd_setImageWithURL:placeholderImage:options:
  * @see sd_setImageWithURL:placeholderImage:options:
  */
  */
-- (void)sd_setBackgroundImageWithURL:(NSURL *)url forState:(UIControlState)state placeholderImage:(UIImage *)placeholder;
+- (void)sd_setBackgroundImageWithURL:(nullable NSURL *)url
+                            forState:(UIControlState)state
+                    placeholderImage:(nullable UIImage *)placeholder;
 
 
 /**
 /**
  * Set the backgroundImageView `image` with an `url`, placeholder and custom options.
  * Set the backgroundImageView `image` with an `url`, placeholder and custom options.
@@ -140,7 +158,10 @@
  * @param placeholder The image to be set initially, until the image request finishes.
  * @param placeholder The image to be set initially, until the image request finishes.
  * @param options     The options to use when downloading the image. @see SDWebImageOptions for the possible values.
  * @param options     The options to use when downloading the image. @see SDWebImageOptions for the possible values.
  */
  */
-- (void)sd_setBackgroundImageWithURL:(NSURL *)url forState:(UIControlState)state placeholderImage:(UIImage *)placeholder options:(SDWebImageOptions)options;
+- (void)sd_setBackgroundImageWithURL:(nullable NSURL *)url
+                            forState:(UIControlState)state
+                    placeholderImage:(nullable UIImage *)placeholder
+                             options:(SDWebImageOptions)options;
 
 
 /**
 /**
  * Set the backgroundImageView `image` with an `url`.
  * Set the backgroundImageView `image` with an `url`.
@@ -155,7 +176,9 @@
  *                       indicating if the image was retrieved from the local cache or from the network.
  *                       indicating if the image was retrieved from the local cache or from the network.
  *                       The fourth parameter is the original image url.
  *                       The fourth parameter is the original image url.
  */
  */
-- (void)sd_setBackgroundImageWithURL:(NSURL *)url forState:(UIControlState)state completed:(SDExternalCompletionBlock)completedBlock;
+- (void)sd_setBackgroundImageWithURL:(nullable NSURL *)url
+                            forState:(UIControlState)state
+                           completed:(nullable SDExternalCompletionBlock)completedBlock;
 
 
 /**
 /**
  * Set the backgroundImageView `image` with an `url`, placeholder.
  * Set the backgroundImageView `image` with an `url`, placeholder.
@@ -171,7 +194,10 @@
  *                       indicating if the image was retrieved from the local cache or from the network.
  *                       indicating if the image was retrieved from the local cache or from the network.
  *                       The fourth parameter is the original image url.
  *                       The fourth parameter is the original image url.
  */
  */
-- (void)sd_setBackgroundImageWithURL:(NSURL *)url forState:(UIControlState)state placeholderImage:(UIImage *)placeholder completed:(SDExternalCompletionBlock)completedBlock;
+- (void)sd_setBackgroundImageWithURL:(nullable NSURL *)url
+                            forState:(UIControlState)state
+                    placeholderImage:(nullable UIImage *)placeholder
+                           completed:(nullable SDExternalCompletionBlock)completedBlock;
 
 
 /**
 /**
  * Set the backgroundImageView `image` with an `url`, placeholder and custom options.
  * Set the backgroundImageView `image` with an `url`, placeholder and custom options.
@@ -187,7 +213,11 @@
  *                       indicating if the image was retrieved from the local cache or from the network.
  *                       indicating if the image was retrieved from the local cache or from the network.
  *                       The fourth parameter is the original image url.
  *                       The fourth parameter is the original image url.
  */
  */
-- (void)sd_setBackgroundImageWithURL:(NSURL *)url forState:(UIControlState)state placeholderImage:(UIImage *)placeholder options:(SDWebImageOptions)options completed:(SDExternalCompletionBlock)completedBlock;
+- (void)sd_setBackgroundImageWithURL:(nullable NSURL *)url
+                            forState:(UIControlState)state
+                    placeholderImage:(nullable UIImage *)placeholder
+                             options:(SDWebImageOptions)options
+                           completed:(nullable SDExternalCompletionBlock)completedBlock;
 
 
 /**
 /**
  * Cancel the current image download
  * Cancel the current image download

@@ -12,9 +12,11 @@
 
 
 static char imageURLStorageKey;
 static char imageURLStorageKey;
 
 
+typedef NSMutableDictionary<NSNumber *, NSURL *> SDStateImageURLDictionary;
+
 @implementation UIButton (WebCache)
 @implementation UIButton (WebCache)
 
 
-- (NSURL *)sd_currentImageURL {
+- (nullable NSURL *)sd_currentImageURL {
     NSURL *url = self.imageURLStorage[@(self.state)];
     NSURL *url = self.imageURLStorage[@(self.state)];
 
 
     if (!url) {
     if (!url) {
@@ -24,32 +26,35 @@ static char imageURLStorageKey;
     return url;
     return url;
 }
 }
 
 
-- (NSURL *)sd_imageURLForState:(UIControlState)state {
+- (nullable NSURL *)sd_imageURLForState:(UIControlState)state {
     return self.imageURLStorage[@(state)];
     return self.imageURLStorage[@(state)];
 }
 }
 
 
-- (void)sd_setImageWithURL:(NSURL *)url forState:(UIControlState)state {
+- (void)sd_setImageWithURL:(nullable NSURL *)url forState:(UIControlState)state {
     [self sd_setImageWithURL:url forState:state placeholderImage:nil options:0 completed:nil];
     [self sd_setImageWithURL:url forState:state placeholderImage:nil options:0 completed:nil];
 }
 }
 
 
-- (void)sd_setImageWithURL:(NSURL *)url forState:(UIControlState)state placeholderImage:(UIImage *)placeholder {
+- (void)sd_setImageWithURL:(nullable NSURL *)url forState:(UIControlState)state placeholderImage:(nullable UIImage *)placeholder {
     [self sd_setImageWithURL:url forState:state placeholderImage:placeholder options:0 completed:nil];
     [self sd_setImageWithURL:url forState:state placeholderImage:placeholder options:0 completed:nil];
 }
 }
 
 
-- (void)sd_setImageWithURL:(NSURL *)url forState:(UIControlState)state placeholderImage:(UIImage *)placeholder options:(SDWebImageOptions)options {
+- (void)sd_setImageWithURL:(nullable NSURL *)url forState:(UIControlState)state placeholderImage:(nullable UIImage *)placeholder options:(SDWebImageOptions)options {
     [self sd_setImageWithURL:url forState:state placeholderImage:placeholder options:options completed:nil];
     [self sd_setImageWithURL:url forState:state placeholderImage:placeholder options:options completed:nil];
 }
 }
 
 
-- (void)sd_setImageWithURL:(NSURL *)url forState:(UIControlState)state completed:(SDExternalCompletionBlock)completedBlock {
+- (void)sd_setImageWithURL:(nullable NSURL *)url forState:(UIControlState)state completed:(nullable SDExternalCompletionBlock)completedBlock {
     [self sd_setImageWithURL:url forState:state placeholderImage:nil options:0 completed:completedBlock];
     [self sd_setImageWithURL:url forState:state placeholderImage:nil options:0 completed:completedBlock];
 }
 }
 
 
-- (void)sd_setImageWithURL:(NSURL *)url forState:(UIControlState)state placeholderImage:(UIImage *)placeholder completed:(SDExternalCompletionBlock)completedBlock {
+- (void)sd_setImageWithURL:(nullable NSURL *)url forState:(UIControlState)state placeholderImage:(nullable UIImage *)placeholder completed:(nullable SDExternalCompletionBlock)completedBlock {
     [self sd_setImageWithURL:url forState:state placeholderImage:placeholder options:0 completed:completedBlock];
     [self sd_setImageWithURL:url forState:state placeholderImage:placeholder options:0 completed:completedBlock];
 }
 }
 
 
-- (void)sd_setImageWithURL:(NSURL *)url forState:(UIControlState)state placeholderImage:(UIImage *)placeholder options:(SDWebImageOptions)options completed:(SDExternalCompletionBlock)completedBlock {
-
+- (void)sd_setImageWithURL:(nullable NSURL *)url
+                  forState:(UIControlState)state
+          placeholderImage:(nullable UIImage *)placeholder
+                   options:(SDWebImageOptions)options
+                 completed:(nullable SDExternalCompletionBlock)completedBlock {
     [self setImage:placeholder forState:state];
     [self setImage:placeholder forState:state];
     [self sd_cancelImageLoadForState:state];
     [self sd_cancelImageLoadForState:state];
     
     
@@ -90,27 +95,31 @@ static char imageURLStorageKey;
     [self sd_setImageLoadOperation:operation forState:state];
     [self sd_setImageLoadOperation:operation forState:state];
 }
 }
 
 
-- (void)sd_setBackgroundImageWithURL:(NSURL *)url forState:(UIControlState)state {
+- (void)sd_setBackgroundImageWithURL:(nullable NSURL *)url forState:(UIControlState)state {
     [self sd_setBackgroundImageWithURL:url forState:state placeholderImage:nil options:0 completed:nil];
     [self sd_setBackgroundImageWithURL:url forState:state placeholderImage:nil options:0 completed:nil];
 }
 }
 
 
-- (void)sd_setBackgroundImageWithURL:(NSURL *)url forState:(UIControlState)state placeholderImage:(UIImage *)placeholder {
+- (void)sd_setBackgroundImageWithURL:(nullable NSURL *)url forState:(UIControlState)state placeholderImage:(nullable UIImage *)placeholder {
     [self sd_setBackgroundImageWithURL:url forState:state placeholderImage:placeholder options:0 completed:nil];
     [self sd_setBackgroundImageWithURL:url forState:state placeholderImage:placeholder options:0 completed:nil];
 }
 }
 
 
-- (void)sd_setBackgroundImageWithURL:(NSURL *)url forState:(UIControlState)state placeholderImage:(UIImage *)placeholder options:(SDWebImageOptions)options {
+- (void)sd_setBackgroundImageWithURL:(nullable NSURL *)url forState:(UIControlState)state placeholderImage:(nullable UIImage *)placeholder options:(SDWebImageOptions)options {
     [self sd_setBackgroundImageWithURL:url forState:state placeholderImage:placeholder options:options completed:nil];
     [self sd_setBackgroundImageWithURL:url forState:state placeholderImage:placeholder options:options completed:nil];
 }
 }
 
 
-- (void)sd_setBackgroundImageWithURL:(NSURL *)url forState:(UIControlState)state completed:(SDExternalCompletionBlock)completedBlock {
+- (void)sd_setBackgroundImageWithURL:(nullable NSURL *)url forState:(UIControlState)state completed:(nullable SDExternalCompletionBlock)completedBlock {
     [self sd_setBackgroundImageWithURL:url forState:state placeholderImage:nil options:0 completed:completedBlock];
     [self sd_setBackgroundImageWithURL:url forState:state placeholderImage:nil options:0 completed:completedBlock];
 }
 }
 
 
-- (void)sd_setBackgroundImageWithURL:(NSURL *)url forState:(UIControlState)state placeholderImage:(UIImage *)placeholder completed:(SDExternalCompletionBlock)completedBlock {
+- (void)sd_setBackgroundImageWithURL:(nullable NSURL *)url forState:(UIControlState)state placeholderImage:(nullable UIImage *)placeholder completed:(nullable SDExternalCompletionBlock)completedBlock {
     [self sd_setBackgroundImageWithURL:url forState:state placeholderImage:placeholder options:0 completed:completedBlock];
     [self sd_setBackgroundImageWithURL:url forState:state placeholderImage:placeholder options:0 completed:completedBlock];
 }
 }
 
 
-- (void)sd_setBackgroundImageWithURL:(NSURL *)url forState:(UIControlState)state placeholderImage:(UIImage *)placeholder options:(SDWebImageOptions)options completed:(SDExternalCompletionBlock)completedBlock {
+- (void)sd_setBackgroundImageWithURL:(nullable NSURL *)url
+                            forState:(UIControlState)state
+                    placeholderImage:(nullable UIImage *)placeholder
+                             options:(SDWebImageOptions)options
+                           completed:(nullable SDExternalCompletionBlock)completedBlock {
     [self sd_cancelBackgroundImageLoadForState:state];
     [self sd_cancelBackgroundImageLoadForState:state];
 
 
     [self setBackgroundImage:placeholder forState:state];
     [self setBackgroundImage:placeholder forState:state];
@@ -162,8 +171,8 @@ static char imageURLStorageKey;
     [self sd_cancelImageLoadOperationWithKey:[NSString stringWithFormat:@"UIButtonBackgroundImageOperation%@", @(state)]];
     [self sd_cancelImageLoadOperationWithKey:[NSString stringWithFormat:@"UIButtonBackgroundImageOperation%@", @(state)]];
 }
 }
 
 
-- (NSMutableDictionary *)imageURLStorage {
-    NSMutableDictionary *storage = objc_getAssociatedObject(self, &imageURLStorageKey);
+- (SDStateImageURLDictionary *)imageURLStorage {
+    SDStateImageURLDictionary *storage = objc_getAssociatedObject(self, &imageURLStorageKey);
     if (!storage)
     if (!storage)
     {
     {
         storage = [NSMutableDictionary dictionary];
         storage = [NSMutableDictionary dictionary];

@@ -10,6 +10,6 @@
 
 
 @interface UIImage (MultiFormat)
 @interface UIImage (MultiFormat)
 
 
-+ (UIImage *)sd_imageWithData:(NSData *)data;
++ (nullable UIImage *)sd_imageWithData:(nullable NSData *)data;
 
 
 @end
 @end

@@ -17,7 +17,7 @@
 
 
 @implementation UIImage (MultiFormat)
 @implementation UIImage (MultiFormat)
 
 
-+ (UIImage *)sd_imageWithData:(NSData *)data {
++ (nullable UIImage *)sd_imageWithData:(nullable NSData *)data {
     if (!data) {
     if (!data) {
         return nil;
         return nil;
     }
     }
@@ -48,7 +48,7 @@
 }
 }
 
 
 
 
-+(UIImageOrientation)sd_imageOrientationFromImageData:(NSData *)imageData {
++(UIImageOrientation)sd_imageOrientationFromImageData:(nonnull NSData *)imageData {
     UIImageOrientation result = UIImageOrientationUp;
     UIImageOrientation result = UIImageOrientationUp;
     CGImageSourceRef imageSource = CGImageSourceCreateWithData((__bridge CFDataRef)imageData, NULL);
     CGImageSourceRef imageSource = CGImageSourceCreateWithData((__bridge CFDataRef)imageData, NULL);
     if (imageSource) {
     if (imageSource) {

@@ -12,7 +12,7 @@
 
 
 @interface UIImage (WebP)
 @interface UIImage (WebP)
 
 
-+ (UIImage *)sd_imageWithWebPData:(NSData *)data;
++ (nullable UIImage *)sd_imageWithWebPData:(nullable NSData *)data;
 
 
 @end
 @end
 
 

@@ -16,14 +16,13 @@
 #endif
 #endif
 
 
 // Callback for CGDataProviderRelease
 // Callback for CGDataProviderRelease
-static void FreeImageData(void *info, const void *data, size_t size)
-{
+static void FreeImageData(void *info, const void *data, size_t size) {
     free((void *)data);
     free((void *)data);
 }
 }
 
 
 @implementation UIImage (WebP)
 @implementation UIImage (WebP)
 
 
-+ (UIImage *)sd_imageWithWebPData:(NSData *)data {
++ (nullable UIImage *)sd_imageWithWebPData:(nullable NSData *)data {
     WebPDecoderConfig config;
     WebPDecoderConfig config;
     if (!WebPInitDecoderConfig(&config)) {
     if (!WebPInitDecoderConfig(&config)) {
         return nil;
         return nil;

@@ -22,7 +22,7 @@
  *
  *
  * @param url The url for the image.
  * @param url The url for the image.
  */
  */
-- (void)sd_setHighlightedImageWithURL:(NSURL *)url;
+- (void)sd_setHighlightedImageWithURL:(nullable NSURL *)url;
 
 
 /**
 /**
  * Set the imageView `highlightedImage` with an `url` and custom options.
  * Set the imageView `highlightedImage` with an `url` and custom options.
@@ -32,7 +32,8 @@
  * @param url     The url for the image.
  * @param url     The url for the image.
  * @param options The options to use when downloading the image. @see SDWebImageOptions for the possible values.
  * @param options The options to use when downloading the image. @see SDWebImageOptions for the possible values.
  */
  */
-- (void)sd_setHighlightedImageWithURL:(NSURL *)url options:(SDWebImageOptions)options;
+- (void)sd_setHighlightedImageWithURL:(nullable NSURL *)url
+                              options:(SDWebImageOptions)options;
 
 
 /**
 /**
  * Set the imageView `highlightedImage` with an `url`.
  * Set the imageView `highlightedImage` with an `url`.
@@ -46,7 +47,8 @@
  *                       indicating if the image was retrieved from the local cache or from the network.
  *                       indicating if the image was retrieved from the local cache or from the network.
  *                       The fourth parameter is the original image url.
  *                       The fourth parameter is the original image url.
  */
  */
-- (void)sd_setHighlightedImageWithURL:(NSURL *)url completed:(SDExternalCompletionBlock)completedBlock;
+- (void)sd_setHighlightedImageWithURL:(nullable NSURL *)url
+                            completed:(nullable SDExternalCompletionBlock)completedBlock;
 
 
 /**
 /**
  * Set the imageView `highlightedImage` with an `url` and custom options.
  * Set the imageView `highlightedImage` with an `url` and custom options.
@@ -61,7 +63,9 @@
  *                       indicating if the image was retrieved from the local cache or from the network.
  *                       indicating if the image was retrieved from the local cache or from the network.
  *                       The fourth parameter is the original image url.
  *                       The fourth parameter is the original image url.
  */
  */
-- (void)sd_setHighlightedImageWithURL:(NSURL *)url options:(SDWebImageOptions)options completed:(SDExternalCompletionBlock)completedBlock;
+- (void)sd_setHighlightedImageWithURL:(nullable NSURL *)url
+                              options:(SDWebImageOptions)options
+                            completed:(nullable SDExternalCompletionBlock)completedBlock;
 
 
 /**
 /**
  * Set the imageView `highlightedImage` with an `url` and custom options.
  * Set the imageView `highlightedImage` with an `url` and custom options.
@@ -77,7 +81,10 @@
  *                       indicating if the image was retrieved from the local cache or from the network.
  *                       indicating if the image was retrieved from the local cache or from the network.
  *                       The fourth parameter is the original image url.
  *                       The fourth parameter is the original image url.
  */
  */
-- (void)sd_setHighlightedImageWithURL:(NSURL *)url options:(SDWebImageOptions)options progress:(SDWebImageDownloaderProgressBlock)progressBlock completed:(SDExternalCompletionBlock)completedBlock;
+- (void)sd_setHighlightedImageWithURL:(nullable NSURL *)url
+                              options:(SDWebImageOptions)options
+                             progress:(nullable SDWebImageDownloaderProgressBlock)progressBlock
+                            completed:(nullable SDExternalCompletionBlock)completedBlock;
 
 
 /**
 /**
  * Cancel the current download
  * Cancel the current download

@@ -13,45 +13,47 @@
 
 
 @implementation UIImageView (HighlightedWebCache)
 @implementation UIImageView (HighlightedWebCache)
 
 
-- (void)sd_setHighlightedImageWithURL:(NSURL *)url {
+- (void)sd_setHighlightedImageWithURL:(nullable NSURL *)url {
     [self sd_setHighlightedImageWithURL:url options:0 progress:nil completed:nil];
     [self sd_setHighlightedImageWithURL:url options:0 progress:nil completed:nil];
 }
 }
 
 
-- (void)sd_setHighlightedImageWithURL:(NSURL *)url options:(SDWebImageOptions)options {
+- (void)sd_setHighlightedImageWithURL:(nullable NSURL *)url options:(SDWebImageOptions)options {
     [self sd_setHighlightedImageWithURL:url options:options progress:nil completed:nil];
     [self sd_setHighlightedImageWithURL:url options:options progress:nil completed:nil];
 }
 }
 
 
-- (void)sd_setHighlightedImageWithURL:(NSURL *)url completed:(SDExternalCompletionBlock)completedBlock {
+- (void)sd_setHighlightedImageWithURL:(nullable NSURL *)url completed:(nullable SDExternalCompletionBlock)completedBlock {
     [self sd_setHighlightedImageWithURL:url options:0 progress:nil completed:completedBlock];
     [self sd_setHighlightedImageWithURL:url options:0 progress:nil completed:completedBlock];
 }
 }
 
 
-- (void)sd_setHighlightedImageWithURL:(NSURL *)url options:(SDWebImageOptions)options completed:(SDExternalCompletionBlock)completedBlock {
+- (void)sd_setHighlightedImageWithURL:(nullable NSURL *)url options:(SDWebImageOptions)options completed:(nullable SDExternalCompletionBlock)completedBlock {
     [self sd_setHighlightedImageWithURL:url options:options progress:nil completed:completedBlock];
     [self sd_setHighlightedImageWithURL:url options:options progress:nil completed:completedBlock];
 }
 }
 
 
-- (void)sd_setHighlightedImageWithURL:(NSURL *)url options:(SDWebImageOptions)options progress:(SDWebImageDownloaderProgressBlock)progressBlock completed:(SDExternalCompletionBlock)completedBlock {
+- (void)sd_setHighlightedImageWithURL:(nullable NSURL *)url
+                              options:(SDWebImageOptions)options
+                             progress:(nullable SDWebImageDownloaderProgressBlock)progressBlock
+                            completed:(nullable SDExternalCompletionBlock)completedBlock {
     [self sd_cancelCurrentHighlightedImageLoad];
     [self sd_cancelCurrentHighlightedImageLoad];
 
 
     if (url) {
     if (url) {
         __weak __typeof(self)wself = self;
         __weak __typeof(self)wself = self;
         id<SDWebImageOperation> operation = [SDWebImageManager.sharedManager loadImageWithURL:url options:options progress:progressBlock completed:^(UIImage *image, NSData *data, NSError *error, SDImageCacheType cacheType, BOOL finished, NSURL *imageURL) {
         id<SDWebImageOperation> operation = [SDWebImageManager.sharedManager loadImageWithURL:url options:options progress:progressBlock completed:^(UIImage *image, NSData *data, NSError *error, SDImageCacheType cacheType, BOOL finished, NSURL *imageURL) {
             if (!wself) return;
             if (!wself) return;
-            dispatch_main_sync_safe (^
-                                     {
-                                         if (!wself) return;
-                                         if (image && (options & SDWebImageAvoidAutoSetImage) && completedBlock)
-                                         {
-                                             completedBlock(image, error, cacheType, url);
-                                             return;
-                                         }
-                                         else if (image) {
-                                             wself.highlightedImage = image;
-                                             [wself setNeedsLayout];
-                                         }
-                                         if (completedBlock && finished) {
-                                             completedBlock(image, error, cacheType, url);
-                                         }
-                                     });
+            dispatch_main_sync_safe (^{
+                if (!wself) return;
+                if (image && (options & SDWebImageAvoidAutoSetImage) && completedBlock)
+                {
+                    completedBlock(image, error, cacheType, url);
+                    return;
+                }
+                else if (image) {
+                    wself.highlightedImage = image;
+                    [wself setNeedsLayout];
+                }
+                if (completedBlock && finished) {
+                    completedBlock(image, error, cacheType, url);
+                }
+            });
         }];
         }];
         [self sd_setImageLoadOperation:operation forKey:UIImageViewHighlightedWebCacheOperationKey];
         [self sd_setImageLoadOperation:operation forKey:UIImageViewHighlightedWebCacheOperationKey];
     } else {
     } else {

@@ -50,7 +50,7 @@
  * Note that because of the limitations of categories this property can get out of sync
  * Note that because of the limitations of categories this property can get out of sync
  * if you use setImage: directly.
  * if you use setImage: directly.
  */
  */
-- (NSURL *)sd_imageURL;
+- (nullable NSURL *)sd_imageURL;
 
 
 /**
 /**
  * Set the imageView `image` with an `url`.
  * Set the imageView `image` with an `url`.
@@ -59,7 +59,7 @@
  *
  *
  * @param url The url for the image.
  * @param url The url for the image.
  */
  */
-- (void)sd_setImageWithURL:(NSURL *)url;
+- (void)sd_setImageWithURL:(nullable NSURL *)url;
 
 
 /**
 /**
  * Set the imageView `image` with an `url` and a placeholder.
  * Set the imageView `image` with an `url` and a placeholder.
@@ -70,7 +70,8 @@
  * @param placeholder The image to be set initially, until the image request finishes.
  * @param placeholder The image to be set initially, until the image request finishes.
  * @see sd_setImageWithURL:placeholderImage:options:
  * @see sd_setImageWithURL:placeholderImage:options:
  */
  */
-- (void)sd_setImageWithURL:(NSURL *)url placeholderImage:(UIImage *)placeholder;
+- (void)sd_setImageWithURL:(nullable NSURL *)url
+          placeholderImage:(nullable UIImage *)placeholder;
 
 
 /**
 /**
  * Set the imageView `image` with an `url`, placeholder and custom options.
  * Set the imageView `image` with an `url`, placeholder and custom options.
@@ -81,7 +82,9 @@
  * @param placeholder The image to be set initially, until the image request finishes.
  * @param placeholder The image to be set initially, until the image request finishes.
  * @param options     The options to use when downloading the image. @see SDWebImageOptions for the possible values.
  * @param options     The options to use when downloading the image. @see SDWebImageOptions for the possible values.
  */
  */
-- (void)sd_setImageWithURL:(NSURL *)url placeholderImage:(UIImage *)placeholder options:(SDWebImageOptions)options;
+- (void)sd_setImageWithURL:(nullable NSURL *)url
+          placeholderImage:(nullable UIImage *)placeholder
+                   options:(SDWebImageOptions)options;
 
 
 /**
 /**
  * Set the imageView `image` with an `url`.
  * Set the imageView `image` with an `url`.
@@ -95,7 +98,8 @@
  *                       indicating if the image was retrieved from the local cache or from the network.
  *                       indicating if the image was retrieved from the local cache or from the network.
  *                       The fourth parameter is the original image url.
  *                       The fourth parameter is the original image url.
  */
  */
-- (void)sd_setImageWithURL:(NSURL *)url completed:(SDExternalCompletionBlock)completedBlock;
+- (void)sd_setImageWithURL:(nullable NSURL *)url
+                 completed:(nullable SDExternalCompletionBlock)completedBlock;
 
 
 /**
 /**
  * Set the imageView `image` with an `url`, placeholder.
  * Set the imageView `image` with an `url`, placeholder.
@@ -110,7 +114,9 @@
  *                       indicating if the image was retrieved from the local cache or from the network.
  *                       indicating if the image was retrieved from the local cache or from the network.
  *                       The fourth parameter is the original image url.
  *                       The fourth parameter is the original image url.
  */
  */
-- (void)sd_setImageWithURL:(NSURL *)url placeholderImage:(UIImage *)placeholder completed:(SDExternalCompletionBlock)completedBlock;
+- (void)sd_setImageWithURL:(nullable NSURL *)url
+          placeholderImage:(nullable UIImage *)placeholder
+                 completed:(nullable SDExternalCompletionBlock)completedBlock;
 
 
 /**
 /**
  * Set the imageView `image` with an `url`, placeholder and custom options.
  * Set the imageView `image` with an `url`, placeholder and custom options.
@@ -126,7 +132,10 @@
  *                       indicating if the image was retrieved from the local cache or from the network.
  *                       indicating if the image was retrieved from the local cache or from the network.
  *                       The fourth parameter is the original image url.
  *                       The fourth parameter is the original image url.
  */
  */
-- (void)sd_setImageWithURL:(NSURL *)url placeholderImage:(UIImage *)placeholder options:(SDWebImageOptions)options completed:(SDExternalCompletionBlock)completedBlock;
+- (void)sd_setImageWithURL:(nullable NSURL *)url
+          placeholderImage:(nullable UIImage *)placeholder
+                   options:(SDWebImageOptions)options
+                 completed:(nullable SDExternalCompletionBlock)completedBlock;
 
 
 /**
 /**
  * Set the imageView `image` with an `url`, placeholder and custom options.
  * Set the imageView `image` with an `url`, placeholder and custom options.
@@ -143,7 +152,11 @@
  *                       indicating if the image was retrieved from the local cache or from the network.
  *                       indicating if the image was retrieved from the local cache or from the network.
  *                       The fourth parameter is the original image url.
  *                       The fourth parameter is the original image url.
  */
  */
-- (void)sd_setImageWithURL:(NSURL *)url placeholderImage:(UIImage *)placeholder options:(SDWebImageOptions)options progress:(SDWebImageDownloaderProgressBlock)progressBlock completed:(SDExternalCompletionBlock)completedBlock;
+- (void)sd_setImageWithURL:(nullable NSURL *)url
+          placeholderImage:(nullable UIImage *)placeholder
+                   options:(SDWebImageOptions)options
+                  progress:(nullable SDWebImageDownloaderProgressBlock)progressBlock
+                 completed:(nullable SDExternalCompletionBlock)completedBlock;
 
 
 /**
 /**
  * Set the imageView `image` with an `url` and optionally a placeholder image.
  * Set the imageView `image` with an `url` and optionally a placeholder image.
@@ -160,14 +173,18 @@
  *                       indicating if the image was retrieved from the local cache or from the network.
  *                       indicating if the image was retrieved from the local cache or from the network.
  *                       The fourth parameter is the original image url.
  *                       The fourth parameter is the original image url.
  */
  */
-- (void)sd_setImageWithPreviousCachedImageWithURL:(NSURL *)url placeholderImage:(UIImage *)placeholder options:(SDWebImageOptions)options progress:(SDWebImageDownloaderProgressBlock)progressBlock completed:(SDExternalCompletionBlock)completedBlock;
+- (void)sd_setImageWithPreviousCachedImageWithURL:(nullable NSURL *)url
+                                 placeholderImage:(nullable UIImage *)placeholder
+                                          options:(SDWebImageOptions)options
+                                         progress:(nullable SDWebImageDownloaderProgressBlock)progressBlock
+                                        completed:(nullable SDExternalCompletionBlock)completedBlock;
 
 
 /**
 /**
  * Download an array of images and starts them in an animation loop
  * Download an array of images and starts them in an animation loop
  *
  *
  * @param arrayOfURLs An array of NSURL
  * @param arrayOfURLs An array of NSURL
  */
  */
-- (void)sd_setAnimationImagesWithURLs:(NSArray *)arrayOfURLs;
+- (void)sd_setAnimationImagesWithURLs:(nonnull NSArray<NSURL *> *)arrayOfURLs;
 
 
 /**
 /**
  * Cancel the current download
  * Cancel the current download

@@ -17,31 +17,35 @@ static char TAG_ACTIVITY_SHOW;
 
 
 @implementation UIImageView (WebCache)
 @implementation UIImageView (WebCache)
 
 
-- (void)sd_setImageWithURL:(NSURL *)url {
+- (void)sd_setImageWithURL:(nullable NSURL *)url {
     [self sd_setImageWithURL:url placeholderImage:nil options:0 progress:nil completed:nil];
     [self sd_setImageWithURL:url placeholderImage:nil options:0 progress:nil completed:nil];
 }
 }
 
 
-- (void)sd_setImageWithURL:(NSURL *)url placeholderImage:(UIImage *)placeholder {
+- (void)sd_setImageWithURL:(nullable NSURL *)url placeholderImage:(nullable UIImage *)placeholder {
     [self sd_setImageWithURL:url placeholderImage:placeholder options:0 progress:nil completed:nil];
     [self sd_setImageWithURL:url placeholderImage:placeholder options:0 progress:nil completed:nil];
 }
 }
 
 
-- (void)sd_setImageWithURL:(NSURL *)url placeholderImage:(UIImage *)placeholder options:(SDWebImageOptions)options {
+- (void)sd_setImageWithURL:(nullable NSURL *)url placeholderImage:(nullable UIImage *)placeholder options:(SDWebImageOptions)options {
     [self sd_setImageWithURL:url placeholderImage:placeholder options:options progress:nil completed:nil];
     [self sd_setImageWithURL:url placeholderImage:placeholder options:options progress:nil completed:nil];
 }
 }
 
 
-- (void)sd_setImageWithURL:(NSURL *)url completed:(SDExternalCompletionBlock)completedBlock {
+- (void)sd_setImageWithURL:(nullable NSURL *)url completed:(nullable SDExternalCompletionBlock)completedBlock {
     [self sd_setImageWithURL:url placeholderImage:nil options:0 progress:nil completed:completedBlock];
     [self sd_setImageWithURL:url placeholderImage:nil options:0 progress:nil completed:completedBlock];
 }
 }
 
 
-- (void)sd_setImageWithURL:(NSURL *)url placeholderImage:(UIImage *)placeholder completed:(SDExternalCompletionBlock)completedBlock {
+- (void)sd_setImageWithURL:(nullable NSURL *)url placeholderImage:(nullable UIImage *)placeholder completed:(nullable SDExternalCompletionBlock)completedBlock {
     [self sd_setImageWithURL:url placeholderImage:placeholder options:0 progress:nil completed:completedBlock];
     [self sd_setImageWithURL:url placeholderImage:placeholder options:0 progress:nil completed:completedBlock];
 }
 }
 
 
-- (void)sd_setImageWithURL:(NSURL *)url placeholderImage:(UIImage *)placeholder options:(SDWebImageOptions)options completed:(SDExternalCompletionBlock)completedBlock {
+- (void)sd_setImageWithURL:(nullable NSURL *)url placeholderImage:(nullable UIImage *)placeholder options:(SDWebImageOptions)options completed:(nullable SDExternalCompletionBlock)completedBlock {
     [self sd_setImageWithURL:url placeholderImage:placeholder options:options progress:nil completed:completedBlock];
     [self sd_setImageWithURL:url placeholderImage:placeholder options:options progress:nil completed:completedBlock];
 }
 }
 
 
-- (void)sd_setImageWithURL:(NSURL *)url placeholderImage:(UIImage *)placeholder options:(SDWebImageOptions)options progress:(SDWebImageDownloaderProgressBlock)progressBlock completed:(SDExternalCompletionBlock)completedBlock {
+- (void)sd_setImageWithURL:(nullable NSURL *)url
+          placeholderImage:(nullable UIImage *)placeholder
+                   options:(SDWebImageOptions)options
+                  progress:(nullable SDWebImageDownloaderProgressBlock)progressBlock
+                 completed:(nullable SDExternalCompletionBlock)completedBlock {
     [self sd_cancelCurrentImageLoad];
     [self sd_cancelCurrentImageLoad];
     objc_setAssociatedObject(self, &imageURLKey, url, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
     objc_setAssociatedObject(self, &imageURLKey, url, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
 
 
@@ -95,22 +99,26 @@ static char TAG_ACTIVITY_SHOW;
     }
     }
 }
 }
 
 
-- (void)sd_setImageWithPreviousCachedImageWithURL:(NSURL *)url placeholderImage:(UIImage *)placeholder options:(SDWebImageOptions)options progress:(SDWebImageDownloaderProgressBlock)progressBlock completed:(SDExternalCompletionBlock)completedBlock {
+- (void)sd_setImageWithPreviousCachedImageWithURL:(nullable NSURL *)url
+                                 placeholderImage:(nullable UIImage *)placeholder
+                                          options:(SDWebImageOptions)options
+                                         progress:(nullable SDWebImageDownloaderProgressBlock)progressBlock
+                                        completed:(nullable SDExternalCompletionBlock)completedBlock {
     NSString *key = [[SDWebImageManager sharedManager] cacheKeyForURL:url];
     NSString *key = [[SDWebImageManager sharedManager] cacheKeyForURL:url];
     UIImage *lastPreviousCachedImage = [[SDImageCache sharedImageCache] imageFromDiskCacheForKey:key];
     UIImage *lastPreviousCachedImage = [[SDImageCache sharedImageCache] imageFromDiskCacheForKey:key];
     
     
     [self sd_setImageWithURL:url placeholderImage:lastPreviousCachedImage ?: placeholder options:options progress:progressBlock completed:completedBlock];    
     [self sd_setImageWithURL:url placeholderImage:lastPreviousCachedImage ?: placeholder options:options progress:progressBlock completed:completedBlock];    
 }
 }
 
 
-- (NSURL *)sd_imageURL {
+- (nullable NSURL *)sd_imageURL {
     return objc_getAssociatedObject(self, &imageURLKey);
     return objc_getAssociatedObject(self, &imageURLKey);
 }
 }
 
 
-- (void)sd_setAnimationImagesWithURLs:(NSArray *)arrayOfURLs {
+- (void)sd_setAnimationImagesWithURLs:(nonnull NSArray<NSURL *> *)arrayOfURLs {
     [self sd_cancelCurrentAnimationImagesLoad];
     [self sd_cancelCurrentAnimationImagesLoad];
     __weak __typeof(self)wself = self;
     __weak __typeof(self)wself = self;
 
 
-    NSMutableArray *operationsArray = [[NSMutableArray alloc] init];
+    NSMutableArray<id<SDWebImageOperation>> *operationsArray = [[NSMutableArray alloc] init];
 
 
     for (NSURL *logoImageURL in arrayOfURLs) {
     for (NSURL *logoImageURL in arrayOfURLs) {
         id <SDWebImageOperation> operation = [SDWebImageManager.sharedManager loadImageWithURL:logoImageURL options:0 progress:nil completed:^(UIImage *image, NSData *data, NSError *error, SDImageCacheType cacheType, BOOL finished, NSURL *imageURL) {
         id <SDWebImageOperation> operation = [SDWebImageManager.sharedManager loadImageWithURL:logoImageURL options:0 progress:nil completed:^(UIImage *image, NSData *data, NSError *error, SDImageCacheType cacheType, BOOL finished, NSURL *imageURL) {
@@ -119,7 +127,7 @@ static char TAG_ACTIVITY_SHOW;
                 __strong UIImageView *sself = wself;
                 __strong UIImageView *sself = wself;
                 [sself stopAnimating];
                 [sself stopAnimating];
                 if (sself && image) {
                 if (sself && image) {
-                    NSMutableArray *currentImages = [[sself animationImages] mutableCopy];
+                    NSMutableArray<UIImage *> *currentImages = [[sself animationImages] mutableCopy];
                     if (!currentImages) {
                     if (!currentImages) {
                         currentImages = [[NSMutableArray alloc] init];
                         currentImages = [[NSMutableArray alloc] init];
                     }
                     }
@@ -134,7 +142,7 @@ static char TAG_ACTIVITY_SHOW;
         [operationsArray addObject:operation];
         [operationsArray addObject:operation];
     }
     }
 
 
-    [self sd_setImageLoadOperation:[NSArray arrayWithArray:operationsArray] forKey:@"UIImageViewAnimationImages"];
+    [self sd_setImageLoadOperation:[operationsArray copy] forKey:@"UIImageViewAnimationImages"];
 }
 }
 
 
 - (void)sd_cancelCurrentImageLoad {
 - (void)sd_cancelCurrentImageLoad {

@@ -17,20 +17,20 @@
  *  @param operation the operation
  *  @param operation the operation
  *  @param key       key for storing the operation
  *  @param key       key for storing the operation
  */
  */
-- (void)sd_setImageLoadOperation:(id)operation forKey:(NSString *)key;
+- (void)sd_setImageLoadOperation:(nullable id)operation forKey:(nullable NSString *)key;
 
 
 /**
 /**
  *  Cancel all operations for the current UIView and key
  *  Cancel all operations for the current UIView and key
  *
  *
  *  @param key key for identifying the operations
  *  @param key key for identifying the operations
  */
  */
-- (void)sd_cancelImageLoadOperationWithKey:(NSString *)key;
+- (void)sd_cancelImageLoadOperationWithKey:(nullable NSString *)key;
 
 
 /**
 /**
  *  Just remove the operations corresponding to the current UIView and key without cancelling them
  *  Just remove the operations corresponding to the current UIView and key without cancelling them
  *
  *
  *  @param key key for identifying the operations
  *  @param key key for identifying the operations
  */
  */
-- (void)sd_removeImageLoadOperationWithKey:(NSString *)key;
+- (void)sd_removeImageLoadOperationWithKey:(nullable NSString *)key;
 
 
 @end
 @end

@@ -11,10 +11,12 @@
 
 
 static char loadOperationKey;
 static char loadOperationKey;
 
 
+typedef NSMutableDictionary<NSString *, id> SDOperationsDictionary;
+
 @implementation UIView (WebCacheOperation)
 @implementation UIView (WebCacheOperation)
 
 
-- (NSMutableDictionary *)operationDictionary {
-    NSMutableDictionary *operations = objc_getAssociatedObject(self, &loadOperationKey);
+- (SDOperationsDictionary *)operationDictionary {
+    SDOperationsDictionary *operations = objc_getAssociatedObject(self, &loadOperationKey);
     if (operations) {
     if (operations) {
         return operations;
         return operations;
     }
     }
@@ -23,15 +25,17 @@ static char loadOperationKey;
     return operations;
     return operations;
 }
 }
 
 
-- (void)sd_setImageLoadOperation:(id)operation forKey:(NSString *)key {
-    [self sd_cancelImageLoadOperationWithKey:key];
-    NSMutableDictionary *operationDictionary = [self operationDictionary];
-    operationDictionary[key] = operation;
+- (void)sd_setImageLoadOperation:(nullable id)operation forKey:(nullable NSString *)key {
+    if (key) {
+        [self sd_cancelImageLoadOperationWithKey:key];
+        SDOperationsDictionary *operationDictionary = [self operationDictionary];
+        operationDictionary[key] = operation;
+    }
 }
 }
 
 
-- (void)sd_cancelImageLoadOperationWithKey:(NSString *)key {
+- (void)sd_cancelImageLoadOperationWithKey:(nullable NSString *)key {
     // Cancel in progress downloader from queue
     // Cancel in progress downloader from queue
-    NSMutableDictionary *operationDictionary = [self operationDictionary];
+    SDOperationsDictionary *operationDictionary = [self operationDictionary];
     id operations = operationDictionary[key];
     id operations = operationDictionary[key];
     if (operations) {
     if (operations) {
         if ([operations isKindOfClass:[NSArray class]]) {
         if ([operations isKindOfClass:[NSArray class]]) {
@@ -47,9 +51,11 @@ static char loadOperationKey;
     }
     }
 }
 }
 
 
-- (void)sd_removeImageLoadOperationWithKey:(NSString *)key {
-    NSMutableDictionary *operationDictionary = [self operationDictionary];
-    [operationDictionary removeObjectForKey:key];
+- (void)sd_removeImageLoadOperationWithKey:(nullable NSString *)key {
+    if (key) {
+        SDOperationsDictionary *operationDictionary = [self operationDictionary];
+        [operationDictionary removeObjectForKey:key];
+    }
 }
 }
 
 
 @end
 @end

@@ -15,7 +15,7 @@
 	<key>CFBundlePackageType</key>
 	<key>CFBundlePackageType</key>
 	<string>FMWK</string>
 	<string>FMWK</string>
 	<key>CFBundleShortVersionString</key>
 	<key>CFBundleShortVersionString</key>
-	<string>3.8.0</string>
+	<string>3.8.1</string>
 	<key>CFBundleSignature</key>
 	<key>CFBundleSignature</key>
 	<string>????</string>
 	<string>????</string>
 	<key>CFBundleVersion</key>
 	<key>CFBundleVersion</key>