Added SDCallbackPolicyMainAsyncSafe which has better compatibility for UI-related code logic

Handled two cases in real-world app

Author: dreampiggy

SDWebImage/Core/SDCallbackQueue.h

@@ -16,7 +16,9 @@ typedef NS_ENUM(NSUInteger, SDCallbackPolicy) {
     /// 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
+    SDCallbackPolicyInvoke = 2,
+    /// Ensure callback in main queue and main thread, will do `dispatch_async` if the current queue is not main queue; else do invoke `block`. Never use `dispatch_sync`, suitable for UI-related work
+    SDCallbackPolicyMainAsyncSafe = 3
 };
 
 /// SDCallbackQueue is a wrapper used to control how the completionBlock should perform on queues, used by our `Cache`/`Manager`/`Loader`.
@@ -32,7 +34,7 @@ typedef NS_ENUM(NSUInteger, SDCallbackPolicy) {
 /// The global concurrent queue (user-initiated QoS). Using `dispatch_get_global_queue`.
 @property (nonnull, class, readonly) SDCallbackQueue *globalQueue;
 
-/// The current queue's callback policy, defaults to `SDCallbackPolicySafeExecute`, which behaves like the old macro  `dispatch_main_async_safe`
+/// The current queue's callback policy, defaults to `SDCallbackPolicyMainAsyncSafe`, which behaves like the old macro  `dispatch_main_async_safe`
 @property (assign, readwrite) SDCallbackPolicy policy;
 
 - (nonnull instancetype)init NS_UNAVAILABLE;

SDWebImage/Core/SDCallbackQueue.m

@@ -12,6 +12,7 @@
 @interface SDCallbackQueue ()
 
 @property (nonatomic, strong, nonnull) dispatch_queue_t queue;
+@property (nonatomic, strong, nonnull) NSThread *thread;
 
 @end
 
@@ -20,8 +21,21 @@ static void SDReleaseBlock(void *context) {
     CFRelease(context);
 }
 
+static inline void SDSafeMainAsync(dispatch_block_t _Nonnull block) {
+    if (NSThread.isMainThread) {
+        // Match exists `dispatch_main_async_safe` behavior
+        const char *currentLabel = dispatch_queue_get_label(DISPATCH_CURRENT_QUEUE_LABEL);
+        const char *mainLabel = dispatch_queue_get_label(dispatch_get_main_queue());
+        if (mainLabel == currentLabel) {
+            block();
+            return;
+        }
+    }
+    dispatch_async(dispatch_get_main_queue(), block);
+}
+
 static void SDSafeExecute(SDCallbackQueue *callbackQueue, dispatch_block_t _Nonnull block, BOOL async) {
-    // Extendc gcd queue's life cycle
+    // Extend gcd queue's life cycle
     dispatch_queue_t queue = callbackQueue.queue;
     // Special handle for main queue label only (custom queue can have the same label)
     const char *label = dispatch_queue_get_label(queue);
@@ -57,6 +71,9 @@ - (instancetype)initWithDispatchQueue:(dispatch_queue_t)queue {
         CFUUIDRef UUID = CFUUIDCreate(kCFAllocatorDefault);
         dispatch_queue_set_specific(queue, SDCallbackQueueKey, (void *)UUID, SDReleaseBlock);
         _queue = queue;
+        _policy = SDCallbackPolicyMainAsyncSafe;
+        // global queue can execute on main thread, like call `dispatch_sync(globalQueue)` in main thread
+        _thread = NSThread.currentThread;
     }
     return self;
 }
@@ -94,6 +111,9 @@ - (void)sync:(nonnull dispatch_block_t)block {
         case SDCallbackPolicyInvoke:
             block();
             break;
+        case SDCallbackPolicyMainAsyncSafe:
+            SDSafeMainAsync(block);
+            break;
         default:
             SDSafeExecute(self, block, NO);
             break;
@@ -111,6 +131,9 @@ - (void)async:(nonnull dispatch_block_t)block {
         case SDCallbackPolicyInvoke:
             block();
             break;
+        case SDCallbackPolicyMainAsyncSafe:
+            SDSafeMainAsync(block);
+            break;
         default:
             SDSafeExecute(self, block, YES);
             break;