@octane-xplat/nativescript-mason-core 0.0.1 → 1.0.0-beta.0

package/platforms/ios/include/SDWebImage/SDAnimatedImagePlayer.h

@@ -0,0 +1,113 @@
+/*
+* This file is part of the SDWebImage package.
+* (c) Olivier Poitrey <rs@dailymotion.com>
+*
+* For the full copyright and license information, please view the LICENSE
+* file that was distributed with this source code.
+*/
+
+#import <Foundation/Foundation.h>
+#import "SDWebImageCompat.h"
+#import "SDImageCoder.h"
+
+/// Animated image playback mode
+typedef NS_ENUM(NSUInteger, SDAnimatedImagePlaybackMode) {
+    /**
+     * From first to last frame and stop or next loop.
+     */
+    SDAnimatedImagePlaybackModeNormal = 0,
+    /**
+     * From last frame to first frame and stop or next loop.
+     */
+    SDAnimatedImagePlaybackModeReverse,
+    /**
+     * From first frame to last frame and reverse again, like reciprocating.
+     */
+    SDAnimatedImagePlaybackModeBounce,
+    /**
+     * From last frame to first frame and reverse again, like reversed reciprocating.
+     */
+    SDAnimatedImagePlaybackModeReversedBounce,
+};
+
+/// A player to control the playback of animated image, which can be used to drive Animated ImageView or any rendering usage, like CALayer/WatchKit/SwiftUI rendering.
+@interface SDAnimatedImagePlayer : NSObject
+
+/// Current playing frame image. This value is KVO Compliance.
+@property (nonatomic, readonly, nullable) UIImage *currentFrame;
+
+/// Current frame index, zero based. This value is KVO Compliance.
+@property (nonatomic, readonly) NSUInteger currentFrameIndex;
+
+/// Current loop count since its latest animating. This value is KVO Compliance.
+@property (nonatomic, readonly) NSUInteger currentLoopCount;
+
+/// Total frame count for animated image rendering. Defaults is animated image's frame count.
+/// @note For progressive animation, you can update this value when your provider receive more frames.
+@property (nonatomic, assign) NSUInteger totalFrameCount;
+
+/// Total loop count for animated image rendering. Default is animated image's loop count.
+@property (nonatomic, assign) NSUInteger totalLoopCount;
+
+/// The animation playback rate. Default is 1.0
+/// `1.0` means the normal speed.
+/// `0.0` means stopping the animation.
+/// `0.0-1.0` means the slow speed.
+/// `> 1.0` means the fast speed.
+/// `< 0.0` is not supported currently and stop animation. (may support reverse playback in the future)
+@property (nonatomic, assign) double playbackRate;
+
+/// Asynchronous setup animation playback mode. Default mode is SDAnimatedImagePlaybackModeNormal.
+@property (nonatomic, assign) SDAnimatedImagePlaybackMode playbackMode;
+
+/// Provide a max buffer size by bytes. This is used to adjust frame buffer count and can be useful when the decoding cost is expensive (such as Animated WebP software decoding). Default is 0.
+/// `0` means automatically adjust by calculating current memory usage.
+/// `1` means without any buffer cache, each of frames will be decoded and then be freed after rendering. (Lowest Memory and Highest CPU)
+/// `NSUIntegerMax` means cache all the buffer. (Lowest CPU and Highest Memory)
+@property (nonatomic, assign) NSUInteger maxBufferSize;
+
+/// You can specify a runloop mode to let it rendering.
+/// Default is NSRunLoopCommonModes on multi-core device, NSDefaultRunLoopMode on single-core device
+@property (nonatomic, copy, nonnull) NSRunLoopMode runLoopMode;
+
+/// Create a player with animated image provider. If the provider's `animatedImageFrameCount` is less than 1, returns nil.
+/// The provider can be any protocol implementation, like `SDAnimatedImage`, `SDImageGIFCoder`, etc.
+/// @note This provider can represent mutable content, like progressive animated loading. But you need to update the frame count by yourself
+/// @param provider The animated provider
+- (nullable instancetype)initWithProvider:(nonnull id<SDAnimatedImageProvider>)provider;
+
+/// Create a player with animated image provider. If the provider's `animatedImageFrameCount` is less than 1, returns nil.
+/// The provider can be any protocol implementation, like `SDAnimatedImage` or `SDImageGIFCoder`, etc.
+/// @note This provider can represent mutable content, like progressive animated loading. But you need to update the frame count by yourself
+/// @param provider The animated provider
++ (nullable instancetype)playerWithProvider:(nonnull id<SDAnimatedImageProvider>)provider;
+
+/// The handler block when current frame and index changed.
+@property (nonatomic, copy, nullable) void (^animationFrameHandler)(NSUInteger index, UIImage * _Nonnull frame);
+
+/// The handler block when one loop count finished.
+@property (nonatomic, copy, nullable) void (^animationLoopHandler)(NSUInteger loopCount);
+
+/// Return the status whether animation is playing.
+@property (nonatomic, readonly) BOOL isPlaying;
+
+/// Start the animation. Or resume the previously paused animation.
+- (void)startPlaying;
+
+/// Pause the animation. Keep the current frame index and loop count.
+- (void)pausePlaying;
+
+/// Stop the animation. Reset the current frame index and loop count.
+- (void)stopPlaying;
+
+/// Seek to the desired frame index and loop count.
+/// @note This can be used for advanced control like progressive loading, or skipping specify frames.
+/// @param index The frame index
+/// @param loopCount The loop count
+- (void)seekToFrameAtIndex:(NSUInteger)index loopCount:(NSUInteger)loopCount;
+
+/// Clear the frame cache buffer. The frame cache buffer size can be controlled by `maxBufferSize`.
+/// By default, when stop or pause the animation, the frame buffer is still kept to ready for the next restart
+- (void)clearFrameBuffer;
+
+@end

package/platforms/ios/include/SDWebImage/SDAnimatedImageRep.h

@@ -0,0 +1,33 @@
+/*
+ * This file is part of the SDWebImage package.
+ * (c) Olivier Poitrey <rs@dailymotion.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+#import "SDWebImageCompat.h"
+
+#if SD_MAC
+
+#import "NSData+ImageContentType.h"
+
+/**
+ A subclass of `NSBitmapImageRep` to fix that GIF duration issue because `NSBitmapImageRep` will reset `NSImageCurrentFrameDuration` by using `kCGImagePropertyGIFDelayTime` but not `kCGImagePropertyGIFUnclampedDelayTime`.
+ This also fix the GIF loop count issue, which will use the Netscape standard (See http://www6.uniovi.es/gifanim/gifabout.htm)  to only place once when the `kCGImagePropertyGIFLoopCount` is nil. This is what modern browser's behavior.
+ Built in GIF coder use this instead of `NSBitmapImageRep` for better GIF rendering. If you do not want this, only enable `SDImageIOCoder`, which just call `NSImage` API and actually use `NSBitmapImageRep` for GIF image.
+ This also support APNG format using `SDImageAPNGCoder`. Which provide full alpha-channel support and the correct duration match the `kCGImagePropertyAPNGUnclampedDelayTime`.
+ */
+@interface SDAnimatedImageRep : NSBitmapImageRep
+
+/// Current animated image format.
+/// @note This format is only valid when `animatedImageData` not nil
+@property (nonatomic, assign, readonly) SDImageFormat animatedImageFormat;
+
+/// This allows to retrive the compressed data like GIF using `sd_imageData` on parent `NSImage`, without re-encoding (waste CPU and RAM)
+/// @note This is typically nonnull when you create with `initWithData:`, even it's marked as weak, because ImageIO retain it
+@property (nonatomic, readonly, nullable, weak) NSData *animatedImageData;
+
+@end
+
+#endif

package/platforms/ios/include/SDWebImage/SDAnimatedImageView+WebCache.h

@@ -0,0 +1,168 @@
+/*
+ * This file is part of the SDWebImage package.
+ * (c) Olivier Poitrey <rs@dailymotion.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+#import "SDAnimatedImageView.h"
+
+#if SD_UIKIT || SD_MAC
+
+#import "SDWebImageManager.h"
+
+/**
+ Integrates SDWebImage async downloading and caching of remote images with SDAnimatedImageView.
+ */
+@interface SDAnimatedImageView (WebCache)
+
+/**
+ * Set the imageView `image` with an `url`.
+ *
+ * The download is asynchronous and cached.
+ *
+ * @param url The url for the image.
+ */
+- (void)sd_setImageWithURL:(nullable NSURL *)url NS_REFINED_FOR_SWIFT;
+
+/**
+ * Set the imageView `image` with an `url` and a placeholder.
+ *
+ * The download is asynchronous and cached.
+ *
+ * @param url         The url for the image.
+ * @param placeholder The image to be set initially, until the image request finishes.
+ * @see sd_setImageWithURL:placeholderImage:options:
+ */
+- (void)sd_setImageWithURL:(nullable NSURL *)url
+          placeholderImage:(nullable UIImage *)placeholder NS_REFINED_FOR_SWIFT;
+
+/**
+ * Set the imageView `image` with an `url`, placeholder and custom options.
+ *
+ * The download is asynchronous and cached.
+ *
+ * @param url         The url for the image.
+ * @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.
+ */
+- (void)sd_setImageWithURL:(nullable NSURL *)url
+          placeholderImage:(nullable UIImage *)placeholder
+                   options:(SDWebImageOptions)options NS_REFINED_FOR_SWIFT;
+
+/**
+ * Set the imageView `image` with an `url`, placeholder, custom options and context.
+ *
+ * The download is asynchronous and cached.
+ *
+ * @param url         The url for the image.
+ * @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 context     A context contains different options to perform specify changes or processes, see `SDWebImageContextOption`. This hold the extra objects which `options` enum can not hold.
+ */
+- (void)sd_setImageWithURL:(nullable NSURL *)url
+          placeholderImage:(nullable UIImage *)placeholder
+                   options:(SDWebImageOptions)options
+                   context:(nullable SDWebImageContext *)context;
+
+/**
+ * Set the imageView `image` with an `url`.
+ *
+ * The download is asynchronous and cached.
+ *
+ * @param url            The url for the image.
+ * @param completedBlock A block called when operation has been completed. This block has no return value
+ *                       and takes the requested UIImage as first parameter. In case of error the image parameter
+ *                       is nil and the second parameter may contain an NSError. The third parameter is a Boolean
+ *                       indicating if the image was retrieved from the local cache or from the network.
+ *                       The fourth parameter is the original image url.
+ */
+- (void)sd_setImageWithURL:(nullable NSURL *)url
+                 completed:(nullable SDExternalCompletionBlock)completedBlock;
+
+/**
+ * Set the imageView `image` with an `url`, placeholder.
+ *
+ * The download is asynchronous and cached.
+ *
+ * @param url            The url for the image.
+ * @param placeholder    The image to be set initially, until the image request finishes.
+ * @param completedBlock A block called when operation has been completed. This block has no return value
+ *                       and takes the requested UIImage as first parameter. In case of error the image parameter
+ *                       is nil and the second parameter may contain an NSError. The third parameter is a Boolean
+ *                       indicating if the image was retrieved from the local cache or from the network.
+ *                       The fourth parameter is the original image url.
+ */
+- (void)sd_setImageWithURL:(nullable NSURL *)url
+          placeholderImage:(nullable UIImage *)placeholder
+                 completed:(nullable SDExternalCompletionBlock)completedBlock NS_REFINED_FOR_SWIFT;
+
+/**
+ * Set the imageView `image` with an `url`, placeholder and custom options.
+ *
+ * The download is asynchronous and cached.
+ *
+ * @param url            The url for the image.
+ * @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 completedBlock A block called when operation has been completed. This block has no return value
+ *                       and takes the requested UIImage as first parameter. In case of error the image parameter
+ *                       is nil and the second parameter may contain an NSError. The third parameter is a Boolean
+ *                       indicating if the image was retrieved from the local cache or from the network.
+ *                       The fourth parameter is the original image url.
+ */
+- (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.
+ *
+ * The download is asynchronous and cached.
+ *
+ * @param url            The url for the image.
+ * @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 progressBlock  A block called while image is downloading
+ *                       @note the progress block is executed on a background queue
+ * @param completedBlock A block called when operation has been completed. This block has no return value
+ *                       and takes the requested UIImage as first parameter. In case of error the image parameter
+ *                       is nil and the second parameter may contain an NSError. The third parameter is a Boolean
+ *                       indicating if the image was retrieved from the local cache or from the network.
+ *                       The fourth parameter is the original image url.
+ */
+- (void)sd_setImageWithURL:(nullable NSURL *)url
+          placeholderImage:(nullable UIImage *)placeholder
+                   options:(SDWebImageOptions)options
+                  progress:(nullable SDImageLoaderProgressBlock)progressBlock
+                 completed:(nullable SDExternalCompletionBlock)completedBlock;
+
+/**
+ * Set the imageView `image` with an `url`, placeholder, custom options and context.
+ *
+ * The download is asynchronous and cached.
+ *
+ * @param url            The url for the image.
+ * @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 context        A context contains different options to perform specify changes or processes, see `SDWebImageContextOption`. This hold the extra objects which `options` enum can not hold.
+ * @param progressBlock  A block called while image is downloading
+ *                       @note the progress block is executed on a background queue
+ * @param completedBlock A block called when operation has been completed. This block has no return value
+ *                       and takes the requested UIImage as first parameter. In case of error the image parameter
+ *                       is nil and the second parameter may contain an NSError. The third parameter is a Boolean
+ *                       indicating if the image was retrieved from the local cache or from the network.
+ *                       The fourth parameter is the original image url.
+ */
+- (void)sd_setImageWithURL:(nullable NSURL *)url
+          placeholderImage:(nullable UIImage *)placeholder
+                   options:(SDWebImageOptions)options
+                   context:(nullable SDWebImageContext *)context
+                  progress:(nullable SDImageLoaderProgressBlock)progressBlock
+                 completed:(nullable SDExternalCompletionBlock)completedBlock;
+
+@end
+
+#endif

package/platforms/ios/include/SDWebImage/SDAnimatedImageView.h

@@ -0,0 +1,125 @@
+/*
+ * This file is part of the SDWebImage package.
+ * (c) Olivier Poitrey <rs@dailymotion.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+#import "SDWebImageCompat.h"
+
+#if SD_UIKIT || SD_MAC
+
+#import "SDAnimatedImage.h"
+#import "SDAnimatedImagePlayer.h"
+#import "SDImageTransformer.h"
+
+/**
+ A drop-in replacement for UIImageView/NSImageView, you can use this for animated image rendering.
+ Call `setImage:` with `UIImage(NSImage)` which conforms to `SDAnimatedImage` protocol will start animated image rendering. Call with normal UIImage(NSImage) will back to normal UIImageView(NSImageView) rendering
+ For UIKit: use `-startAnimating`, `-stopAnimating` to control animating. `isAnimating` to check animation state.
+ For AppKit: use `-setAnimates:` to control animating, `animates` to check animation state. This view is layer-backed.
+ */
+NS_SWIFT_UI_ACTOR
+@interface SDAnimatedImageView : UIImageView
+/**
+ The internal animation player.
+ This property is only used for advanced usage, like inspecting/debugging animation status, control progressive loading, complicated animation frame index control, etc.
+ @warning Pay attention if you directly update the player's property like `totalFrameCount`, `totalLoopCount`, the same property on `SDAnimatedImageView` may not get synced.
+ */
+@property (nonatomic, strong, readonly, nullable) SDAnimatedImagePlayer *player;
+
+/**
+ The transformer for each decoded animated image frame.
+ We supports post-transform on animated image frame from version 5.20.
+ When you configure the transformer on `SDAnimatedImageView` and animation is playing, the `transformedImageWithImage:forKey:` will be called just after the frame is decoded. (note: The `key` arg is always empty for backward-compatible and may be removed in the future)
+ 
+ Example to tint the alpha animated image frame with a black color:
+ * @code
+ imageView.animationTransformer = [SDImageTintTransformer transformerWithColor:UIColor.blackColor];
+ * @endcode
+ @note The `transformerKey` property is used to ensure the buffer cache available. So make sure it's correct value match the actual logic on transformer. Which means, for the `same frame index + same transformer key`, the transformed image should always be the same.
+ */
+@property (nonatomic, strong, nullable) id<SDImageTransformer> animationTransformer;
+
+/**
+ Current display frame image. This value is KVO Compliance.
+ */
+@property (nonatomic, strong, readonly, nullable) UIImage *currentFrame;
+/**
+ Current frame index, zero based. This value is KVO Compliance.
+ */
+@property (nonatomic, assign, readonly) NSUInteger currentFrameIndex;
+/**
+ Current loop count since its latest animating. This value is KVO Compliance.
+ */
+@property (nonatomic, assign, readonly) NSUInteger currentLoopCount;
+/**
+ YES to choose `animationRepeatCount` property for animation loop count. No to use animated image's `animatedImageLoopCount` instead.
+ Default is NO.
+ */
+@property (nonatomic, assign) BOOL shouldCustomLoopCount;
+/**
+ Total loop count for animated image rendering. Default is animated image's loop count.
+ If you need to set custom loop count, set `shouldCustomLoopCount` to YES and change this value.
+ This class override UIImageView's `animationRepeatCount` property on iOS, use this property as well.
+ */
+@property (nonatomic, assign) NSInteger animationRepeatCount;
+/**
+ The animation playback rate. Default is 1.0.
+ `1.0` means the normal speed.
+ `0.0` means stopping the animation.
+ `0.0-1.0` means the slow speed.
+ `> 1.0` means the fast speed.
+ `< 0.0` is not supported currently and stop animation. (may support reverse playback in the future)
+ */
+@property (nonatomic, assign) double playbackRate;
+
+/// Asynchronous setup animation playback mode. Default mode is SDAnimatedImagePlaybackModeNormal.
+@property (nonatomic, assign) SDAnimatedImagePlaybackMode playbackMode;
+
+/**
+ Provide a max buffer size by bytes. This is used to adjust frame buffer count and can be useful when the decoding cost is expensive (such as Animated WebP software decoding). Default is 0.
+ `0` means automatically adjust by calculating current memory usage.
+ `1` means without any buffer cache, each of frames will be decoded and then be freed after rendering. (Lowest Memory and Highest CPU)
+ `NSUIntegerMax` means cache all the buffer. (Lowest CPU and Highest Memory)
+ */
+@property (nonatomic, assign) NSUInteger maxBufferSize;
+/**
+ Whehter or not to enable incremental image load for animated image. This is for the animated image which `sd_isIncremental` is YES (See `UIImage+Metadata.h`). If enable, animated image rendering will stop at the last frame available currently, and continue when another `setImage:` trigger, where the new animated image's `animatedImageData` should be updated from the previous one. If the `sd_isIncremental` is NO. The incremental image load stop.
+ @note If you are confused about this description, open Chrome browser to view some large GIF images with low network speed to see the animation behavior.
+ @note The best practice to use incremental load is using `initWithAnimatedCoder:scale:` in `SDAnimatedImage` with animated coder which conform to `SDProgressiveImageCoder` as well. Then call incremental update and incremental decode method to produce the image.
+ Default is YES. Set to NO to only render the static poster for incremental animated image.
+ */
+@property (nonatomic, assign) BOOL shouldIncrementalLoad;
+
+/**
+ Whether or not to clear the frame buffer cache when animation stopped. See `maxBufferSize`
+ This is useful when you want to limit the memory usage during frequently visibility changes (such as image view inside a list view, then push and pop)
+ Default is NO.
+ */
+@property (nonatomic, assign) BOOL clearBufferWhenStopped;
+
+/**
+ Whether or not to reset the current frame index when animation stopped.
+ For some of use case, you may want to reset the frame index to 0 when stop, but some other want to keep the current frame index.
+ Default is NO.
+ */
+@property (nonatomic, assign) BOOL resetFrameIndexWhenStopped;
+
+/**
+ If the image which conforms to `SDAnimatedImage` protocol has more than one frame, set this value to `YES` will automatically
+ play/stop the animation when the view become visible/invisible.
+ Default is YES.
+ */
+@property (nonatomic, assign) BOOL autoPlayAnimatedImage;
+
+/**
+ You can specify a runloop mode to let it rendering.
+ Default is NSRunLoopCommonModes on multi-core device, NSDefaultRunLoopMode on single-core device
+ @note This is useful for some cases, for example, always specify NSDefaultRunLoopMode, if you want to pause the animation when user scroll (for Mac user, drag the mouse or touchpad)
+ */
+@property (nonatomic, copy, nonnull) NSRunLoopMode runLoopMode;
+@end
+
+#endif

package/platforms/ios/include/SDWebImage/SDCallbackQueue.h

@@ -0,0 +1,59 @@
+/*
+ * This file is part of the SDWebImage package.
+ * (c) Olivier Poitrey <rs@dailymotion.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+
+#import "SDWebImageCompat.h"
+
+/// SDCallbackPolicy controls how we execute the block on the queue, like whether to use `dispatch_async/dispatch_sync`, check if current queue match target queue, or just invoke without any context.
+typedef NS_ENUM(NSUInteger, SDCallbackPolicy) {
+    /// When the current queue is equal to callback queue, sync/async will just invoke `block` directly without dispatch. Else it use `dispatch_async`/`dispatch_sync` to dispatch block on queue. This is useful for UIKit rendering to ensure all blocks executed in the same runloop
+    SDCallbackPolicySafeExecute = 0,
+    /// Follow async/sync using the correspond `dispatch_async`/`dispatch_sync` to dispatch block on queue
+    SDCallbackPolicyDispatch = 1,
+    /// Ignore any async/sync and just directly invoke `block` in current queue (without `dispatch_async`/`dispatch_sync`)
+    SDCallbackPolicyInvoke = 2,
+    /// Ensure callback in main thread. Do `dispatch_async` if the `NSThread.isMainTrhead == true` ; else do invoke `block`. Never use `dispatch_sync`, suitable for special UI-related code
+    SDCallbackPolicySafeAsyncMainThread = 3,
+};
+
+/// SDCallbackQueue is a wrapper used to control how the completionBlock should perform on queues, used by our `Cache`/`Manager`/`Loader`.
+/// Useful when you call SDWebImage in non-main queue and want to avoid it callback into main queue, which may cause issue.
+@interface SDCallbackQueue : NSObject
+
+/// The main queue. This is the default value, has the same effect when passing `nil` to `SDWebImageContextCallbackQueue`
+/// The policy defaults to `SDCallbackPolicySafeAsyncMainThread`
+@property (nonnull, class, readonly) SDCallbackQueue *mainQueue;
+
+/// The caller current queue. Using `dispatch_get_current_queue`. This is not a dynamic value and only keep the first call time queue.
+/// The policy defaults to `SDCallbackPolicySafeExecute`
+@property (nonnull, class, readonly) SDCallbackQueue *currentQueue;
+
+/// The global concurrent queue (user-initiated QoS). Using `dispatch_get_global_queue`.
+/// The policy defaults to `SDCallbackPolicySafeExecute`
+@property (nonnull, class, readonly) SDCallbackQueue *globalQueue;
+
+/// The current queue's callback policy.
+@property (nonatomic, assign, readwrite) SDCallbackPolicy policy;
+
+- (nonnull instancetype)init NS_UNAVAILABLE;
++ (nonnull instancetype)new  NS_UNAVAILABLE;
+/// Create the callback queue with a GCD queue. The policy defaults to `SDCallbackPolicySafeExecute`
+/// - Parameter queue: The GCD queue, should not be NULL
+- (nonnull instancetype)initWithDispatchQueue:(nonnull dispatch_queue_t)queue NS_DESIGNATED_INITIALIZER;
+
+#pragma mark - Execution Entry
+
+/// Submits a block for execution and returns after that block finishes executing.
+/// - Parameter block: The block that contains the work to perform.
+- (void)sync:(nonnull dispatch_block_t)block API_DEPRECATED("No longer use, may cause deadlock when misused", macos(10.10, 10.10), ios(8.0, 8.0), tvos(9.0, 9.0), watchos(2.0, 2.0));;
+
+/// Schedules a block asynchronously for execution.
+/// - Parameter block: The block that contains the work to perform.
+- (void)async:(nonnull dispatch_block_t)block;
+
+@end

package/platforms/ios/include/SDWebImage/SDDiskCache.h

@@ -0,0 +1,146 @@
+/*
+ * This file is part of the SDWebImage package.
+ * (c) Olivier Poitrey <rs@dailymotion.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+#import "SDWebImageCompat.h"
+
+@class SDImageCacheConfig;
+/**
+ A protocol to allow custom disk cache used in SDImageCache.
+ */
+@protocol SDDiskCache <NSObject>
+
+// All of these method are called from the same global queue to avoid blocking on main queue and thread-safe problem. But it's also recommend to ensure thread-safe yourself using lock or other ways.
+@required
+/**
+ Create a new disk cache based on the specified path. You can check `maxDiskSize` and `maxDiskAge` used for disk cache.
+ 
+ @param cachePath Full path of a directory in which the cache will write data.
+ Once initialized you should not read and write to this directory.
+ @param config The cache config to be used to create the cache.
+ 
+ @return A new cache object, or nil if an error occurs.
+ */
+- (nullable instancetype)initWithCachePath:(nonnull NSString *)cachePath config:(nonnull SDImageCacheConfig *)config;
+
+/**
+ Returns a boolean value that indicates whether a given key is in cache.
+ This method may blocks the calling thread until file read finished.
+ 
+ @param key A string identifying the data. If nil, just return NO.
+ @return Whether the key is in cache.
+ */
+- (BOOL)containsDataForKey:(nonnull NSString *)key;
+
+/**
+ Returns the data associated with a given key.
+ This method may blocks the calling thread until file read finished.
+ 
+ @param key A string identifying the data. If nil, just return nil.
+ @return The value associated with key, or nil if no value is associated with key.
+ */
+- (nullable NSData *)dataForKey:(nonnull NSString *)key;
+
+/**
+ Sets the value of the specified key in the cache.
+ This method may blocks the calling thread until file write finished.
+ 
+ @param data The data to be stored in the cache.
+ @param key    The key with which to associate the value. If nil, this method has no effect.
+ */
+- (void)setData:(nullable NSData *)data forKey:(nonnull NSString *)key;
+
+/**
+ Returns the extended data associated with a given key.
+ This method may blocks the calling thread until file read finished.
+ 
+ @param key A string identifying the data. If nil, just return nil.
+ @return The value associated with key, or nil if no value is associated with key.
+ */
+- (nullable NSData *)extendedDataForKey:(nonnull NSString *)key;
+
+/**
+ Set extended data with a given key.
+ 
+ @discussion You can set any extended data to exist cache key. Without override the exist disk file data.
+ on UNIX, the common way for this is to use the Extended file attributes (xattr)
+ 
+ @param extendedData The extended data (pass nil to remove).
+ @param key The key with which to associate the value. If nil, this method has no effect.
+*/
+- (void)setExtendedData:(nullable NSData *)extendedData forKey:(nonnull NSString *)key;
+
+/**
+ Removes the value of the specified key in the cache.
+ This method may blocks the calling thread until file delete finished.
+ 
+ @param key The key identifying the value to be removed. If nil, this method has no effect.
+ */
+- (void)removeDataForKey:(nonnull NSString *)key;
+
+/**
+ Empties the cache.
+ This method may blocks the calling thread until file delete finished.
+ */
+- (void)removeAllData;
+
+/**
+ Removes the expired data from the cache. You can choose the data to remove base on `ageLimit`, `countLimit` and `sizeLimit` options.
+ */
+- (void)removeExpiredData;
+
+/**
+ The cache path for key
+
+ @param key A string identifying the value
+ @return The cache path for key. Or nil if the key can not associate to a path
+ */
+- (nullable NSString *)cachePathForKey:(nonnull NSString *)key;
+
+/**
+ Returns the number of data in this cache.
+ This method may blocks the calling thread until file read finished.
+ 
+ @return The total data count.
+ */
+- (NSUInteger)totalCount;
+
+/**
+ Returns the total size (in bytes) of data in this cache.
+ This method may blocks the calling thread until file read finished.
+ 
+ @return The total data size in bytes.
+ */
+- (NSUInteger)totalSize;
+
+@end
+
+/**
+ The built-in disk cache.
+ */
+@interface SDDiskCache : NSObject <SDDiskCache>
+/**
+ Cache Config object - storing all kind of settings.
+ */
+@property (nonatomic, strong, readonly, nonnull) SDImageCacheConfig *config;
+
+- (nonnull instancetype)init NS_UNAVAILABLE;
++ (nonnull instancetype)new  NS_UNAVAILABLE;
+
+/**
+ Move the cache directory from old location to new location, the old location will be removed after finish.
+ If the old location does not exist, does nothing.
+ If the new location does not exist, only do a movement of directory.
+ If the new location does exist, will move and merge the files from old location.
+ If the new location does exist, but is not a directory, will remove it and do a movement of directory.
+
+ @param srcPath old location of cache directory
+ @param dstPath new location of cache directory
+ */
+- (void)moveCacheDirectoryFromPath:(nonnull NSString *)srcPath toPath:(nonnull NSString *)dstPath;
+
+@end