development: refactors Animation class

486cab29 · Daniel Dahan · c97e64b6 · 486cab29 · 486cab29 · 486cab29
Commit 486cab29 authored Oct 25, 2016 by Daniel Dahan
7 changed files
--- a/Sources/iOS/Animation.swift
+++ b/Sources/iOS/Animation.swift
@@ -57,20 +57,21 @@ public func AnimationFillModeToValue(mode: AnimationFillMode) -> String {
 @objc(AnimationTimingFunction)
 public enum AnimationTimingFunction: Int {
-    case liner
+    case linear
    case easeIn
    case easeOut
    case easeInEaseOut
-    case systemDefault
+    case `default`
 }
 /**
 Converts the AnimationTimingFunction enum value to a corresponding CAMediaTimingFunction.
 - Parameter function: An AnimationTimingFunction enum value.
+ - Returns: A CAMediaTimingFunction.
 */
 public func AnimationTimingFunctionToValue(function: AnimationTimingFunction) -> CAMediaTimingFunction {
    switch function {
-    case .liner:
+    case .linear:
        return CAMediaTimingFunction(name: kCAMediaTimingFunctionLinear)
    case .easeIn:
        return CAMediaTimingFunction(name: kCAMediaTimingFunctionEaseIn)
@@ -78,18 +79,23 @@ public func AnimationTimingFunctionToValue(function: AnimationTimingFunction) ->
        return CAMediaTimingFunction(name: kCAMediaTimingFunctionEaseOut)
    case .easeInEaseOut:
        return CAMediaTimingFunction(name: kCAMediaTimingFunctionEaseInEaseOut)
-    case .systemDefault:
+    case .default:
        return CAMediaTimingFunction(name: kCAMediaTimingFunctionDefault)
    }
 }
 public typealias AnimationDelayCancelBlock = (Bool) -> Void
 public struct Animation {
-	/// Delay helper method.
+	/**
+     Executes a block of code after a time delay.
+     - Parameter duration: An animation duration time.
+     - Parameter animations: An animation block.
+     - Parameter execute block: A completion block that is executed once
+     the animations have completed.
+     */
    @discardableResult
-    public static func delay(time: TimeInterval, completion: @escaping () -> Void) -> AnimationDelayCancelBlock? {
+    public static func delay(time: TimeInterval, execute block: @escaping () -> Void) -> AnimationDelayCancelBlock? {
 		func asyncAfter(completion: @escaping () -> Void) {
 			DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + time, execute: completion)
@@ -97,10 +103,11 @@ public struct Animation {
 		var cancelable: AnimationDelayCancelBlock?
-		let delayed: AnimationDelayCancelBlock = { (cancel) in
+		let delayed: AnimationDelayCancelBlock = {
-			if !cancel {
+			if !$0 {
-				DispatchQueue.main.async(execute: completion)
+				DispatchQueue.main.async(execute: block)
 			}
 			cancelable = nil
 		}
@@ -114,24 +121,30 @@ public struct Animation {
 	}
 	/**
-	:name:	delayCancel
+     Cancels the delayed AnimationDelayCancelBlock.
-	*/
+     - Parameter delayed completion: An AnimationDelayCancelBlock.
-	public static func delayCancel(completion: AnimationDelayCancelBlock) {
+     */
+	public static func cancel(delayed completion: AnimationDelayCancelBlock) {
 		completion(true)
 	}
 	/**
-	:name:	animationDisabled
+     Disables the default animations set on CALayers. 
-	*/
+     - Parameter animations: A callback that wraps the animations to disable.
-	public static func animationDisabled(animations: (() -> Void)) {
+     */
-		animateWithDuration(duration: 0, animations: animations)
+	public static func disable(animations: (() -> Void)) {
+		animate(duration: 0, animations: animations)
 	}
 	/**
-	:name:	animateWithDuration
+     Runs an animation with a specified duration.
-	*/
+     - Parameter duration: An animation duration time.
-	public static func animateWithDuration(duration: CFTimeInterval, animations: (() -> Void), completion: (() -> Void)? = nil) {
+     - Parameter animations: An animation block.
+     - Parameter completion: A completion block that is executed once
+     the animations have completed.
+     */
+	public static func animate(duration: CFTimeInterval, animations: (() -> Void), completion: (() -> Void)? = nil) {
 		CATransaction.begin()
 		CATransaction.setAnimationDuration(duration)
 		CATransaction.setCompletionBlock(completion)
@@ -141,9 +154,12 @@ public struct Animation {
 	}
 	/**
-	:name:	animationGroup
+     Creates a CAAnimationGroup.
-	*/
+     - Parameter animations: An Array of CAAnimation objects.
-	public static func animationGroup(animations: [CAAnimation], duration: CFTimeInterval = 0.5) -> CAAnimationGroup {
+     - Parameter duration: An animation duration time for the group.
+     - Returns: A CAAnimationGroup.
+     */
+	public static func animate(group animations: [CAAnimation], duration: CFTimeInterval = 0.5) -> CAAnimationGroup {
 		let group: CAAnimationGroup = CAAnimationGroup()
 		group.fillMode = AnimationFillModeToValue(mode: .forwards)
 		group.isRemovedOnCompletion = false
@@ -154,11 +170,16 @@ public struct Animation {
 	}
 	/**
-	:name:	animateWithDelay
+     Executes an animation block with a given delay and duration.
-	*/
+     - Parameter delay time: A CFTimeInterval.
-	public static func animateWithDelay(delay d: CFTimeInterval, duration: CFTimeInterval, animations: @escaping (() -> Void), completion: (() -> Void)? = nil) {
+     - Parameter duration: An animation duration time.
-        delay(time: d) {
+     - Parameter animations: An animation block.
-            animateWithDuration(duration: duration, animations: animations, completion: completion)
+     - Parameter completion: A completion block that is executed once
+     the animations have completed.
+     */
+	public static func animate(delay time: CFTimeInterval, duration: CFTimeInterval, animations: @escaping (() -> Void), completion: (() -> Void)? = nil) {
+        delay(time: time) {
+            animate(duration: duration, animations: animations, completion: completion)
 		}
 	}
 }
--- a/Sources/iOS/BasicAnimation.swift
+++ b/Sources/iOS/BasicAnimation.swift
--- a/Sources/iOS/Capture/Capture.swift
+++ b/Sources/iOS/Capture/Capture.swift
@@ -629,7 +629,7 @@ open class Capture: View, UIGestureRecognizerDelegate {
 	/// Animates the tap and layer.
 	private func animateTap(view: UIView, point: CGPoint) {
-//		Animation.animationDisabled { [weak layer] in
+//		Animation.disable { [weak layer] in
 //            guard let v = layer else {
 //                return
 //            }
@@ -644,7 +644,7 @@ open class Capture: View, UIGestureRecognizerDelegate {
 //			v.transform = CATransform3DMakeScale(0.5, 0.5, 1)
 //		}) {
 //			Animation.delay(time: 0.4) { [weak layer] in
-//                Animation.animationDisabled { [weak layer] in
+//                Animation.disable { [weak layer] in
 //                    guard let v = layer else {
 //                        return
 //                    }

--- a/Sources/iOS/KeyframeAnimation.swift
+++ b/Sources/iOS/KeyframeAnimation.swift
@@ -32,19 +32,21 @@ import UIKit
 @objc(AnimationRotationMode)
 public enum AnimationRotationMode: Int {
-	case none
+	case `default`
 	case auto
 	case autoReverse
 }
 /**
-	:name:	AnimationRotationModeToValue
+ Converts an AnimationRotationMode to a corresponding CAAnimationRotate key.
-*/
+ - Parameter mode: An AnimationRotationMode.
+ - Returns: An optional CAAnimationRotate key String.
+ */
 public func AnimationRotationModeToValue(mode: AnimationRotationMode) -> String? {
 	switch mode {
-	case .none:
+    case .default:
-		return nil
+        return nil
-	case .auto:
+    case .auto:
 		return kCAAnimationRotateAuto
 	case .autoReverse:
 		return kCAAnimationRotateAutoReverse
@@ -53,11 +55,15 @@ public func AnimationRotationModeToValue(mode: AnimationRotationMode) -> String?
 extension Animation {
 	/**
-	:name: path
+     Creates a CAKeyframeAnimation.
-	*/
+     - Parameter bezierPath: A UIBezierPath.
+     - Parameter mode: An AnimationRotationMode.
+     - Parameter duration: An animation duration time.
+     - Returns: A CAKeyframeAnimation.
+     */
 	public static func path(bezierPath: UIBezierPath, mode: AnimationRotationMode = .auto, duration: CFTimeInterval? = nil) -> CAKeyframeAnimation {
-		let animation: CAKeyframeAnimation = CAKeyframeAnimation()
+		let animation = CAKeyframeAnimation()
-		animation.keyPath = AnimationKey.position.rawValue
+		animation.keyPath = AnimationKeyPath.position.rawValue
 		animation.path = bezierPath.cgPath
        animation.rotationMode = AnimationRotationModeToValue(mode: mode)
 		if let v = duration {

--- a/Sources/iOS/Material+CALayer.swift
+++ b/Sources/iOS/Material+CALayer.swift
@@ -321,7 +321,7 @@ extension CALayer {
        } else if nil == shadowPath {
            shadowPath = UIBezierPath(roundedRect: bounds, cornerRadius: cornerRadius).cgPath
        } else {
-            let a = Animation.shadowPath(path: UIBezierPath(roundedRect: bounds, cornerRadius: cornerRadius).cgPath)
+            let a = Animation.shadowPath(to: UIBezierPath(roundedRect: bounds, cornerRadius: cornerRadius).cgPath)
            a.fromValue = shadowPath
            animate(animation: a)
        }

--- a/Sources/iOS/PulseAnimation.swift
+++ b/Sources/iOS/PulseAnimation.swift
@@ -71,7 +71,7 @@ internal extension Animation {
        visualLayer.masksToBounds = !(.centerRadialBeyondBounds == pulse.animation || .radialBeyondBounds == pulse.animation)
-        Animation.animationDisabled(animations: { [visualLayer = visualLayer, pulse = pulse] in
+        Animation.disable(animations: { [visualLayer = visualLayer, pulse = pulse] in
            bLayer.frame = visualLayer.bounds
            pLayer.bounds = CGRect(x: 0, y: 0, width: n, height: n)
@@ -99,7 +99,7 @@ internal extension Animation {
        switch pulse.animation {
        case .center, .centerWithBacking, .centerRadialBeyondBounds, .radialBeyondBounds, .point, .pointWithBacking:
-            pLayer.add(Animation.scale(scale: 1, duration: duration), forKey: nil)
+            pLayer.add(Animation.scale(by: 1, duration: duration), forKey: nil)
        default:break
        }
@@ -138,8 +138,8 @@ internal extension Animation {
            switch pulse.animation {
            case .center, .centerWithBacking, .centerRadialBeyondBounds, .radialBeyondBounds, .point, .pointWithBacking:
-                pLayer.add(Animation.animationGroup(animations: [
+                pLayer.add(Animation.animate(group: [
-                    Animation.scale(scale: .center == pulse.animation ? 1 : 1.325),
+                    Animation.scale(by: .center == pulse.animation ? 1 : 1.325),
                    Animation.backgroundColor(color: pulse.color.withAlphaComponent(0))
                ], duration: duration), forKey: nil)
            default:break

--- a/Sources/iOS/TransitionAnimation.swift
+++ b/Sources/iOS/TransitionAnimation.swift
@@ -30,70 +30,78 @@
 import UIKit
-public typealias AnimationTransitionType = String
-public typealias AnimationTransitionSubTypeType = String
 @objc(AnimationTransition)
 public enum AnimationTransition: Int {
-	case Fade
+	case fade
-	case MoveIn
+	case moveIn
-	case Push
+	case push
-	case Reveal
+	case reveal
 }
-@objc(AnimationTransitionSubType)
+@objc(AnimationTransitionDirection)
-public enum AnimationTransitionSubType: Int {
+public enum AnimationTransitionDirection: Int {
-	case Right
+	case `default`
-	case Left
+    case right
-	case Top
+	case left
-	case Bottom
+	case top
+	case bottom
 }
 /**
-	:name:	AnimationTransitionToValue
+ Converts an AnimationTransition to a corresponding CATransition key.
-*/
+ - Parameter transition: An AnimationTransition.
-public func AnimationTransitionToValue(transition: AnimationTransition) -> AnimationTransitionType {
+ - Returns: A CATransition key String.
-	switch transition {
+ */
-	case .Fade:
+public func AnimationTransitionToValue(transition type: AnimationTransition) -> String {
+	switch type {
+	case .fade:
 		return kCATransitionFade
-	case .MoveIn:
+	case .moveIn:
 		return kCATransitionMoveIn
-	case .Push:
+	case .push:
 		return kCATransitionPush
-	case .Reveal:
+	case .reveal:
 		return kCATransitionReveal
 	}
 }
 /**
-	:name:	AnimationTransitionSubTypeToValue
+ Converts an AnimationTransitionDirection to a corresponding CATransition direction key.
-*/
+ - Parameter direction: An AnimationTransitionDirection.
-public func AnimationTransitionSubTypeToValue(direction: AnimationTransitionSubType) -> AnimationTransitionSubTypeType {
+ - Returns: An optional CATransition direction key String.
+ */
+public func AnimationTransitionDirectionToValue(direction: AnimationTransitionDirection) -> String? {
 	switch direction {
-	case .Right:
+    case .default:
+        return nil
+    case .right:
 		return kCATransitionFromRight
-	case .Left:
+	case .left:
 		return kCATransitionFromLeft
-	case .Top:
+	case .top:
 		return kCATransitionFromBottom
-	case .Bottom:
+	case .bottom:
 		return kCATransitionFromTop
 	}
 }
 extension Animation {
 	/**
-	:name: transition
+     Creates a CATransition animation.
-	*/
+     - Parameter type: An AnimationTransition.
-	public static func transition(type: AnimationTransition, direction: AnimationTransitionSubType? = nil, duration: CFTimeInterval? = nil) -> CATransition {
+     - Parameter direction: An optional AnimationTransitionDirection.
-		let animation: CATransition = CATransition()
+     - Parameter duration: An optional duration time.
+     - Returns: A CATransition.
+     */
+	public static func transition(type: AnimationTransition, direction: AnimationTransitionDirection = .default, duration: CFTimeInterval? = nil) -> CATransition {
+		let animation = CATransition()
 		animation.type = AnimationTransitionToValue(transition: type)
-		if let d = direction {
+        animation.subtype = AnimationTransitionDirectionToValue(direction: direction)
-			animation.subtype = AnimationTransitionSubTypeToValue(direction: d)
-		}
+        if let v = duration {
-		if let v: CFTimeInterval = duration {
 			animation.duration = v
 		}
-		return animation
+        return animation
 	}
 }