wait for any unfinished animations

Author: gabriellanata

Sources/Hammer/EventGenerator/EventGenerator.swift

@@ -121,6 +121,13 @@ public final class EventGenerator {
         }
     }
 
+    /// Waits until animations are finished.
+    ///
+    /// - parameter timeout: The maximum time to wait for the window to be ready.
+    public func waitUntilAnimationsAreFinished(timeout: TimeInterval) throws {
+        try self.waitUntil(!self.hasRunningAnimations, timeout: timeout)
+    }
+
     /// Returns if the window is ready to receive user interaction events
     public var isWindowReady: Bool {
         guard !(UIApplication.shared as UIApplicationDeprecated).isIgnoringInteractionEvents
@@ -148,6 +155,32 @@ public final class EventGenerator {
         return true
     }
 
+    // Returns if the view or any of its subviews has running animations.
+    public var hasRunningAnimations: Bool {
+        // Recursive
+        func hasRunningAnimations(currentView: UIView) -> Bool {
+            // If the view is not visible, we do not need to consider it as running animation
+            guard self.viewIsVisible(currentView) else {
+                return false
+            }
+
+            // If there are animations running on the layer, return true
+            if currentView.layer.animationKeys()?.isEmpty == false {
+                return true
+            }
+
+            // Special case for parallax dimming view which happens during some animations
+            if String(describing: type(of: currentView)) == "_UIParallaxDimmingView" {
+                return true
+            }
+
+            // Traverse subviews
+            return currentView.subviews.contains { hasRunningAnimations(currentView: $0) }
+        }
+
+        return hasRunningAnimations(currentView: self.window)
+    }
+
     /// Gets the next event ID to use. Event IDs are global and sequential.
     ///
     /// - returns: The next event ID.

Sources/Hammer/Utilties/Subviews.swift

@@ -154,31 +154,7 @@ extension EventGenerator {
     ///
     /// - returns: If the view is visible
     public func viewIsVisible(_ view: UIView, visibility: Visibility = .partial) -> Bool {
-        guard view.isDescendant(of: self.window) else {
-            return false
-        }
-
-        // Recursive
-        func viewIsVisible(currentView: UIView) -> Bool {
-            guard !currentView.isHidden && currentView.alpha >= 0.01 else {
-                return false
-            }
-
-            guard let superview = currentView.superview else {
-                return currentView == self.window
-            }
-
-            if superview.clipsToBounds {
-                let adjustedBounds = view.convert(view.bounds, to: superview)
-                guard superview.bounds.isVisible(adjustedBounds, visibility: visibility) else {
-                    return false
-                }
-            }
-
-            return viewIsVisible(currentView: superview)
-        }
-
-        return viewIsVisible(currentView: view)
+        return view.isVisible(inWindow: self.window, visibility: visibility)
     }
 
     /// Returns if the specified rect is visible.

Sources/Hammer/Utilties/UIKit+Extensions.swift

@@ -75,4 +75,38 @@ extension UIView {
     var topLevelView: UIView {
         return self.superview?.topLevelView ?? self
     }
+
+    /// Returns if the view is visible.
+    ///
+    /// - parameter window:     The window to check if the view is part of.
+    /// - parameter visibility: How determine if the view is visible.
+    ///
+    /// - returns: If the view is visible
+    func isVisible(inWindow window: UIWindow, visibility: EventGenerator.Visibility = .partial) -> Bool {
+        guard self.isDescendant(of: window) else {
+            return false
+        }
+
+        // Recursive
+        func isVisible(currentView: UIView) -> Bool {
+            guard !currentView.isHidden && currentView.alpha >= 0.01 else {
+                return false
+            }
+
+            guard let superview = currentView.superview else {
+                return currentView == window
+            }
+
+            if superview.clipsToBounds {
+                let adjustedBounds = self.convert(self.bounds, to: superview)
+                guard superview.bounds.isVisible(adjustedBounds, visibility: visibility) else {
+                    return false
+                }
+            }
+
+            return isVisible(currentView: superview)
+        }
+
+        return isVisible(currentView: self)
+    }
 }