部分需求修改

2023-10-24 10:09:59 +08:00
parent 529d44d51d
commit c11aab7e05
45 changed files with 8039 additions and 8542 deletions
--- a/Pods/DDTimerSwiftKit_Private/DDTimerSwiftKit_Private/Classes/GCDTimer/GCDTimer.swift
+++ b/Pods/DDTimerSwiftKit_Private/DDTimerSwiftKit_Private/Classes/GCDTimer/GCDTimer.swift
@@ -12,10 +12,8 @@ open class GCDTimer {
    public static let `default` = GCDTimer()
    
    private var timerSources : [GCDTimerAbstract] = []
-    
-    private var canceledCompletionHandler:(() -> Void)? // 主动取消定时器时，由于定时器当前可能存在任务，所以要等任务结束后再进行相应的操作
-    
-    private var removeQueue = DispatchQueue(label: "GCDTimerRemoveQueue") // 移除定时器的时候，由于存在多个定时器同时移除的情况，定时器本身是异步操作的，所以从timerSources中移除GCDTimerAbstract的操作也是异步的，这就会导致数组在遍历的同时也在从数组中删除项目，会有问题，所以把删除的操作放在同步队列中
+      
+    private var timerAddOrRemoveQueue = DispatchQueue(label: "GCDTimerAddOrRemoveQueue") // 移除定时器的时候，由于存在多个定时器同时移除的情况，定时器本身是异步操作的，所以从timerSources中移除GCDTimerAbstract的操作也是异步的，这就会导致数组在遍历的同时也在从数组中删除项目，会有问题，所以把删除的操作放在同步队列中
    
    /// 取消定时器时，定时器如果有正在执行的任务，会先将当前正在执行的任务执行完成才会取消成功，因此如果需要添加相同名字的定时器，需要确保之前同名的定时器已经被彻底取消了。
    /// - Parameters:
@@ -27,63 +25,92 @@ open class GCDTimer {
    ///   - cancelHandler: 如果执行了cancelHandler，就不会执行completionHandler
    ///   - completionHandler: 如果执行了completionHandler，就不会执行cancelHandler
    public func addGCDTimer(named timerName:String,delay:DispatchTimeInterval,repeating:DispatchTimeInterval,repeatCount:Int = Int.max,repeatHandler:@escaping (() -> Void),cancelHandler:(() -> Void)? = nil,completionHandler:(() -> Void)? = nil) {
-        if let _ = timerSources.first(where: { gcdTimerA in
-            gcdTimerA.timerName == timerName
-        }) {
-            DDLog(message: "定时器\'\(timerName)\'重复添加，添加失败")
-            return
-        }
-        
-        let gcdTimerA = GCDTimerAbstract(named: timerName)
-        gcdTimerA.addGCDTimer(delay: delay, repeating: repeating, repeatCount: repeatCount) {
-            repeatHandler()
-        } cancelHandler: {[weak self] timerName in
-            // 移除定时器
-            self?.removeGCDTimer(named: timerName,removeComletionHandler: {[weak self] in
-                // 添加定时器处执行取消操作
-                if let cancelHandler {
-                    cancelHandler()
-                }
-                // 取消定时器处执行取消操作
-                if let canceledCompletionHandler = self?.canceledCompletionHandler {
-                    canceledCompletionHandler()
-                }
-            })
-        } completionHandler: {[weak self] timerName in
-            // 移除定时器
-            self?.removeGCDTimer(named: timerName,removeComletionHandler: {
-                // 执行结束操作
-                if let completionHandler {
-                    completionHandler()
-                }
-            })
-        }
+        timerAddOrRemoveQueue.async { [weak self] in
+            if let _ = self?.timerSources.first(where: { gcdTimerA in
+                gcdTimerA.timerName == timerName
+            }) {
+                DDLog(message: "定时器\'\(timerName)\'重复添加，添加失败")
+                return
+            }
+            
+            let gcdTimerA = GCDTimerAbstract(named: timerName)
+            gcdTimerA.addGCDTimer(delay: delay, repeating: repeating, repeatCount: repeatCount) {
+                repeatHandler()
+            } cancelHandler: {[weak self] (timerName,canceledCompletionHandler) in
+                // 移除定时器
+                self?.removeGCDTimer(named: timerName,removeComletionHandler: {
+                    // 添加定时器处执行取消操作
+                    if let cancelHandler {
+                        cancelHandler()
+                    }
+                    // 取消定时器处执行取消操作
+                    if let canceledCompletionHandler {
+                        canceledCompletionHandler()
+                    }
+                })
+            } completionHandler: {[weak self] (timerName,canceledCompletionHandler) in
+                // 移除定时器
+                self?.removeGCDTimer(named: timerName,removeComletionHandler: {
+                    // 执行结束操作
+                    if let completionHandler {
+                        completionHandler()
+                    }
+                    // 这是一种特殊的情况，当且仅当主动取消定时器时，定时器正在进行最后一次任务操作
+                    if let canceledCompletionHandler {
+                        canceledCompletionHandler()
+                    }
+                })
+            }

-        timerSources.append(gcdTimerA)
-        DDLog(message: "定时器\'\(timerName)\'添加成功")
-        // 打印剩余的定时器
-        logTimerName()
+            self?.timerSources.append(gcdTimerA)
+            DDLog(message: "定时器\'\(timerName)\'添加成功")
+            // 打印剩余的定时器
+            self?.logTimerName()
+        }
    }
    
+    func removeGCDTimer(named timerName:String,removeComletionHandler:@escaping () -> Void) {
+        timerAddOrRemoveQueue.async { [weak self] in
+            // 移除定时器的抽象类
+            if let index = self?.timerSources.firstIndex(where: { gcdTimerA in
+                gcdTimerA.timerName == timerName
+            }) {
+                self?.timerSources.remove(at: index)
+                DDLog(message: "定时器\'\(timerName)\'移除成功")
+                
+                // 异步操作回调
+                DispatchQueue.global().async {
+                    removeComletionHandler()
+                }
+            }
+            // 打印剩余的定时器
+            self?.logTimerName()
+        }
+        
+    }
    
    /// 在取消定时器时，假如定时器正在执行任务，这个过程中被多次取消且携带了canceledCompletionHandler，只会执行最后一次赋值的canceledCompletionHandler。
    /// - Parameters:
    ///   - timerName: 定时器名字
    ///   - canceledCompletionHandler: 取消定时器后的操作
    public func cancelGCDTimer(named timerName:String,canceledCompletionHandler:(() -> Void)? = nil) {
-        self.canceledCompletionHandler = canceledCompletionHandler
-        
-        // 当timerSources中包含定时器时，取消定时器
-        if let gcdTimerA = timerSources.first(where: { gcdTimerA in
-            gcdTimerA.timerName == timerName
-        }) {
-            gcdTimerA.cancelGCDTimer(isCanceledManually: true)
-        }else{
-            if let canceledCompletionHandler {
-                canceledCompletionHandler()
+        timerAddOrRemoveQueue.async {[weak self] in
+            // 当timerSources中包含定时器时，取消定时器
+            if let gcdTimerA = self?.timerSources.first(where: { gcdTimerA in
+                gcdTimerA.timerName == timerName
+            }) {
+                gcdTimerA.canceledCompletionHandler = canceledCompletionHandler
+                gcdTimerA.cancelGCDTimer(isCanceledManually: true)
+            }else{
+                // 异步操作回调
+                DispatchQueue.global().async {
+                    if let canceledCompletionHandler {
+                        canceledCompletionHandler()
+                    }
+                }
+                // 打印剩余的定时器
+                self?.logTimerName()
            }
-            // 打印剩余的定时器
-            logTimerName()
        }
    }
    
@@ -96,20 +123,6 @@ open class GCDTimer {
        return false
    }
    
-    func removeGCDTimer(named timerName:String,removeComletionHandler:@escaping () -> Void) {
-        removeQueue.sync {[weak self] in
-            // 移除定时器的抽象类
-            if let index = self?.timerSources.firstIndex(where: { gcdTimerA in
-                gcdTimerA.timerName == timerName
-            }) {
-                self?.timerSources.remove(at: index)
-                DDLog(message: "定时器\'\(timerName)\'移除成功")
-            }
-            // 打印剩余的定时器
-            self?.logTimerName()
-        }
-    }
-    
    func logTimerName() {
        var array : [String] = []
        for gcdTimerA in timerSources {
@@ -128,11 +141,13 @@ class GCDTimerAbstract {

    public var isCanceledManually : Bool = false // 是否时主动取消定时器
    
+    public var canceledCompletionHandler:(() -> Void)? // 主动取消定时器时，由于定时器当前可能存在任务，所以要等任务结束后再进行相应的操作
+  
    init(named timerName: String) {
        self.timerName = timerName
    }
    
-    public func addGCDTimer(delay:DispatchTimeInterval,repeating:DispatchTimeInterval,repeatCount:Int,repeatHandler:@escaping (() -> Void),cancelHandler:((String) -> Void)? = nil,completionHandler: ((String) -> Void)? = nil) {
+    public func addGCDTimer(delay:DispatchTimeInterval,repeating:DispatchTimeInterval,repeatCount:Int,repeatHandler:@escaping (() -> Void),cancelHandler:((String,(() -> Void)?) -> Void)? = nil,completionHandler: ((String,(() -> Void)?) -> Void)? = nil) {
        // 当前剩余的次数
        var leftRepeatCount = repeatCount
        
@@ -143,6 +158,7 @@ class GCDTimerAbstract {
            leftRepeatCount-=1
            // 此时定时器次数结束
            if (leftRepeatCount > 0) == false {
+                // 这里有一种特殊情况，当主动cancel了定时器，且在进行最后一次任务的时候，最后一次任务执行完正好来到这里，那么依然要调用canceledCompletionHandler
                self?.cancelGCDTimer(isCanceledManually: false)
            }
        })
@@ -151,12 +167,12 @@ class GCDTimerAbstract {
            if self?.isCanceledManually == true {
                // 定时器中途被取消时,在添加定时器的位置需要执行的取消操作
                if let cancelHandler,let timerName = self?.timerName {
-                    cancelHandler(timerName)
+                    cancelHandler(timerName,self?.canceledCompletionHandler)
                }
            }else{
                // 定时器结束后执行
                if let completionHandler,let timerName = self?.timerName {
-                    completionHandler(timerName)
+                    completionHandler(timerName,self?.canceledCompletionHandler)
                }
            }
        })