lottie-ios 3.2.0 → 3.4.0

package/{lottie-swift/src → Sources}/Public/iOS/AnimatedControl.swift

@@ -6,133 +6,160 @@
 //
 
 import Foundation
-#if os(iOS) || os(tvOS) || os(watchOS)
+#if os(iOS) || os(tvOS) || os(watchOS) || targetEnvironment(macCatalyst)
 import UIKit
 
-/**
- Lottie comes prepacked with a two Animated Controls, `AnimatedSwitch` and
- `AnimatedButton`. Both of these controls are built on top of `AnimatedControl`
- 
- `AnimatedControl` is a subclass of `UIControl` that provides an interactive
- mechanism for controlling the visual state of an animation in response to
- user actions.
- 
- The `AnimatedControl` will show and hide layers depending on the current
- `UIControl.State` of the control.
- 
- Users of `AnimationControl` can set a Layer Name for each `UIControl.State`.
- When the state is change the `AnimationControl` will change the visibility
- of its layers.
- 
- NOTE: Do not initialize directly. This is intended to be subclassed.
- */
+/// Lottie comes prepacked with a two Animated Controls, `AnimatedSwitch` and
+/// `AnimatedButton`. Both of these controls are built on top of `AnimatedControl`
+///
+/// `AnimatedControl` is a subclass of `UIControl` that provides an interactive
+/// mechanism for controlling the visual state of an animation in response to
+/// user actions.
+///
+/// The `AnimatedControl` will show and hide layers depending on the current
+/// `UIControl.State` of the control.
+///
+/// Users of `AnimationControl` can set a Layer Name for each `UIControl.State`.
+/// When the state is change the `AnimationControl` will change the visibility
+/// of its layers.
+///
+/// NOTE: Do not initialize directly. This is intended to be subclassed.
 open class AnimatedControl: UIControl {
-  
-  // MARK: Public
-  
-  /// The animation view in which the animation is rendered.
-  public let animationView: AnimationView
-  
-  /// The animation backing the animated control.
-  public var animation: Animation? {
-    didSet {
-      animationView.animation = animation
-      animationView.bounds = animation?.bounds ?? .zero
-      setNeedsLayout()
-      updateForState()
-      animationDidSet()
-    }
-  }
 
-  /// The speed of the animation playback. Defaults to 1
-  public var animationSpeed: CGFloat {
-    set { animationView.animationSpeed = newValue }
-    get { return animationView.animationSpeed }
-  }
-  
-  /// Sets which Animation Layer should be visible for the given state.
-  public func setLayer(named: String, forState: UIControl.State) {
-    stateMap[forState.rawValue] = named
-    updateForState()
-  }
+  // MARK: Lifecycle
 
-  /// Sets a ValueProvider for the specified keypath
-  public func setValueProvider(_ valueProvider: AnyValueProvider, keypath: AnimationKeypath) {
-    animationView.setValueProvider(valueProvider, keypath: keypath)
-  }
-  
   // MARK: Initializers
-  
-  public init(animation: Animation) {
-    self.animationView = AnimationView(animation: animation)
+
+  public init(
+    animation: Animation,
+    configuration: LottieConfiguration = .shared)
+  {
+    animationView = AnimationView(
+      animation: animation,
+      configuration: configuration)
+
     super.init(frame: animation.bounds)
     commonInit()
   }
-  
+
   public init() {
-    self.animationView = AnimationView()
+    animationView = AnimationView()
     super.init(frame: .zero)
     commonInit()
   }
-  
+
   required public init?(coder aDecoder: NSCoder) {
-    self.animationView = AnimationView()
+    animationView = AnimationView()
     super.init(coder: aDecoder)
     commonInit()
   }
-  
+
+  // MARK: Open
+
   // MARK: UIControl Overrides
-  
+
   open override var isEnabled: Bool {
     didSet {
       updateForState()
     }
   }
-  
+
   open override var isSelected: Bool {
     didSet {
       updateForState()
     }
   }
-  
+
   open override var isHighlighted: Bool {
     didSet {
       updateForState()
     }
   }
-  
+
+  open override var intrinsicContentSize: CGSize {
+    animationView.intrinsicContentSize
+  }
+
   open override func beginTracking(_ touch: UITouch, with event: UIEvent?) -> Bool {
     updateForState()
     return super.beginTracking(touch, with: event)
   }
-  
+
   open override func continueTracking(_ touch: UITouch, with event: UIEvent?) -> Bool {
     updateForState()
     return super.continueTracking(touch, with: event)
   }
-  
+
   open override func endTracking(_ touch: UITouch?, with event: UIEvent?) {
     updateForState()
     return super.endTracking(touch, with: event)
   }
-  
+
   open override func cancelTracking(with event: UIEvent?) {
     updateForState()
     super.cancelTracking(with: event)
   }
-  
-  open override var intrinsicContentSize: CGSize {
-    return animationView.intrinsicContentSize
-  }
-  
+
   open func animationDidSet() {
-    
+
   }
-  
-  // MARK: Private
-  
-  var stateMap: [UInt : String] = [:]
-  
+
+  // MARK: Public
+
+  /// The animation view in which the animation is rendered.
+  public let animationView: AnimationView
+
+  /// The animation backing the animated control.
+  public var animation: Animation? {
+    didSet {
+      animationView.animation = animation
+      animationView.bounds = animation?.bounds ?? .zero
+      setNeedsLayout()
+      updateForState()
+      animationDidSet()
+    }
+  }
+
+  /// The speed of the animation playback. Defaults to 1
+  public var animationSpeed: CGFloat {
+    set { animationView.animationSpeed = newValue }
+    get { animationView.animationSpeed }
+  }
+
+  /// Sets which Animation Layer should be visible for the given state.
+  public func setLayer(named: String, forState: UIControl.State) {
+    stateMap[forState.rawValue] = named
+    updateForState()
+  }
+
+  /// Sets a ValueProvider for the specified keypath
+  public func setValueProvider(_ valueProvider: AnyValueProvider, keypath: AnimationKeypath) {
+    animationView.setValueProvider(valueProvider, keypath: keypath)
+  }
+
+  // MARK: Internal
+
+  var stateMap: [UInt: String] = [:]
+
+  func updateForState() {
+    guard let animationLayer = animationView.animationLayer else { return }
+    if
+      let layerName = stateMap[state.rawValue],
+      let stateLayer = animationLayer.layer(for: AnimationKeypath(keypath: layerName))
+    {
+      for layer in animationLayer._animationLayers {
+        layer.isHidden = true
+      }
+      stateLayer.isHidden = false
+    } else {
+      for layer in animationLayer._animationLayers {
+        layer.isHidden = false
+      }
+    }
+  }
+
+  // MARK: Fileprivate
+
   fileprivate func commonInit() {
     animationView.clipsToBounds = false
     clipsToBounds = true
@@ -146,21 +173,5 @@ open class AnimatedControl: UIControl {
     animationView.topAnchor.constraint(equalTo: topAnchor).isActive = true
     animationView.bottomAnchor.constraint(equalTo: bottomAnchor).isActive = true
   }
-  
-  func updateForState() {
-    guard let animationLayer = animationView.animationLayer else { return }
-    if let layerName = stateMap[state.rawValue],
-        let stateLayer = animationLayer.layer(for: AnimationKeypath(keypath: layerName)) {
-      for layer in animationLayer.animationLayers {
-        layer.isHidden = true
-      }
-      stateLayer.isHidden = false
-    } else {
-      for layer in animationLayer.animationLayers {
-        layer.isHidden = false
-      }
-    }
-  }
-  
 }
 #endif

package/{lottie-swift/src → Sources}/Public/iOS/AnimatedSwitch.swift

@@ -6,114 +6,126 @@
 //
 
 import Foundation
-#if os(iOS) || os(tvOS) || os(watchOS)
+#if os(iOS) || os(tvOS) || os(watchOS) || targetEnvironment(macCatalyst)
 import UIKit
 
-/**
- An interactive switch with an 'On' and 'Off' state. When the user taps on the
- switch the state is toggled and the appropriate animation is played.
- 
- Both the 'On' and 'Off' have an animation play range associated with their state.
- */
-final public class AnimatedSwitch: AnimatedControl {
+/// An interactive switch with an 'On' and 'Off' state. When the user taps on the
+/// switch the state is toggled and the appropriate animation is played.
+///
+/// Both the 'On' and 'Off' have an animation play range associated with their state.
+open class AnimatedSwitch: AnimatedControl {
 
-  /// Defines what happens when the user taps the switch while an
-  /// animation is still in flight
-  public enum CancelBehavior {
-    case reverse // default - plays the current animation in reverse
-    case none    // does not update the animation when canceled
-  }
-  
-  /// The current state of the switch.
-  public var isOn: Bool {
-    set {
-      /// This is forwarded to a private variable because the animation needs to be updated without animation when set externally and with animation when set internally.
-      guard _isOn != newValue else { return }
-      updateOnState(isOn: newValue, animated: false, shouldFireHaptics: false)
-    }
-    get {
-      return _isOn
-    }
-  }
+  // MARK: Lifecycle
 
-  /// The cancel behavior for the switch. See CancelBehavior for options
-  public var cancelBehavior: CancelBehavior = .reverse
-
-  /// Set the state of the switch and specify animation and haptics
-  public func setIsOn(_ isOn: Bool, animated: Bool, shouldFireHaptics: Bool = true) {
-    guard isOn != _isOn else { return }
-    updateOnState(isOn: isOn, animated: animated, shouldFireHaptics: shouldFireHaptics)
-  }
-
-  /// Sets the play range for the given state. When the switch is toggled, the animation range is played.
-  public func setProgressForState(fromProgress: AnimationProgressTime,
-                                  toProgress: AnimationProgressTime,
-                                  forOnState: Bool) {
-    if forOnState {
-      onStartProgress = fromProgress
-      onEndProgress = toProgress
-    } else {
-      offStartProgress = fromProgress
-      offEndProgress = toProgress
-    }
-    
-    updateOnState(isOn: _isOn, animated: false, shouldFireHaptics: false)
-  }
-  
-  public override init(animation: Animation) {
+  public override init(
+    animation: Animation,
+    configuration: LottieConfiguration = .shared)
+  {
     /// Generate a haptic generator if available.
     #if os(iOS)
     if #available(iOS 10.0, *) {
       self.hapticGenerator = HapticGenerator()
     } else {
-      self.hapticGenerator = NullHapticGenerator()
+      hapticGenerator = NullHapticGenerator()
     }
     #else
-    self.hapticGenerator = NullHapticGenerator()
+    hapticGenerator = NullHapticGenerator()
     #endif
-    super.init(animation: animation)
+    super.init(animation: animation, configuration: configuration)
     updateOnState(isOn: _isOn, animated: false, shouldFireHaptics: false)
-    self.accessibilityTraits = UIAccessibilityTraits.button
+    accessibilityTraits = UIAccessibilityTraits.button
   }
-  
+
   public override init() {
     /// Generate a haptic generator if available.
     #if os(iOS)
     if #available(iOS 10.0, *) {
       self.hapticGenerator = HapticGenerator()
     } else {
-      self.hapticGenerator = NullHapticGenerator()
+      hapticGenerator = NullHapticGenerator()
     }
     #else
-    self.hapticGenerator = NullHapticGenerator()
+    hapticGenerator = NullHapticGenerator()
     #endif
     super.init()
     updateOnState(isOn: _isOn, animated: false, shouldFireHaptics: false)
-    self.accessibilityTraits = UIAccessibilityTraits.button
+    accessibilityTraits = UIAccessibilityTraits.button
   }
-  
+
   required public init?(coder aDecoder: NSCoder) {
     /// Generate a haptic generator if available.
     #if os(iOS)
     if #available(iOS 10.0, *) {
       self.hapticGenerator = HapticGenerator()
     } else {
-      self.hapticGenerator = NullHapticGenerator()
+      hapticGenerator = NullHapticGenerator()
     }
     #else
-    self.hapticGenerator = NullHapticGenerator()
+    hapticGenerator = NullHapticGenerator()
     #endif
     super.init(coder: aDecoder)
-    self.accessibilityTraits = UIAccessibilityTraits.button
+    accessibilityTraits = UIAccessibilityTraits.button
   }
-  
-  fileprivate var onStartProgress: CGFloat = 0
-  fileprivate var onEndProgress: CGFloat = 1
-  fileprivate var offStartProgress: CGFloat = 1
-  fileprivate var offEndProgress: CGFloat = 0
-  fileprivate var _isOn: Bool = false
-  fileprivate var hapticGenerator: ImpactGenerator
-  
+
+  // MARK: Public
+
+  /// Defines what happens when the user taps the switch while an
+  /// animation is still in flight
+  public enum CancelBehavior {
+    case reverse // default - plays the current animation in reverse
+    case none // does not update the animation when canceled
+  }
+
+  /// The cancel behavior for the switch. See CancelBehavior for options
+  public var cancelBehavior: CancelBehavior = .reverse
+
+  /// The current state of the switch.
+  public var isOn: Bool {
+    set {
+      /// This is forwarded to a private variable because the animation needs to be updated without animation when set externally and with animation when set internally.
+      guard _isOn != newValue else { return }
+      updateOnState(isOn: newValue, animated: false, shouldFireHaptics: false)
+    }
+    get {
+      _isOn
+    }
+  }
+
+  /// Set the state of the switch and specify animation and haptics
+  public func setIsOn(_ isOn: Bool, animated: Bool, shouldFireHaptics: Bool = true) {
+    guard isOn != _isOn else { return }
+    updateOnState(isOn: isOn, animated: animated, shouldFireHaptics: shouldFireHaptics)
+  }
+
+  /// Sets the play range for the given state. When the switch is toggled, the animation range is played.
+  public func setProgressForState(
+    fromProgress: AnimationProgressTime,
+    toProgress: AnimationProgressTime,
+    forOnState: Bool)
+  {
+    if forOnState {
+      onStartProgress = fromProgress
+      onEndProgress = toProgress
+    } else {
+      offStartProgress = fromProgress
+      offEndProgress = toProgress
+    }
+
+    updateOnState(isOn: _isOn, animated: false, shouldFireHaptics: false)
+  }
+
+  public override func endTracking(_ touch: UITouch?, with event: UIEvent?) {
+    super.endTracking(touch, with: event)
+    updateOnState(isOn: !_isOn, animated: true, shouldFireHaptics: true)
+    sendActions(for: .valueChanged)
+  }
+
+  public override func animationDidSet() {
+    updateOnState(isOn: _isOn, animated: true, shouldFireHaptics: false)
+  }
+
+  // MARK: Internal
+
   // MARK: Animation State
 
   func updateOnState(isOn: Bool, animated: Bool, shouldFireHaptics: Bool) {
@@ -127,8 +139,11 @@ final public class AnimatedSwitch: AnimatedControl {
 
       let previousStateStart = isOn ? offStartProgress : onStartProgress
       let previousStateEnd = isOn ? offEndProgress : onEndProgress
-      if realtimeProgress.isInRange(min(previousStateStart, previousStateEnd),
-                                    max(previousStateStart, previousStateEnd)) {
+      if
+        realtimeProgress.isInRange(
+          min(previousStateStart, previousStateEnd),
+          max(previousStateStart, previousStateEnd))
+      {
         /// Animation is currently in the previous time range. Reverse the previous play.
         startProgress = previousStateEnd
         endProgress = previousStateStart
@@ -136,59 +151,75 @@ final public class AnimatedSwitch: AnimatedControl {
     }
 
     updateAccessibilityLabel()
-    
+
     guard animated == true else {
       animationView.currentProgress = finalProgress
       return
     }
 
     if shouldFireHaptics {
-      self.hapticGenerator.generateImpact()
+      hapticGenerator.generateImpact()
     }
 
-    animationView.play(fromProgress: startProgress, toProgress: endProgress, loopMode: LottieLoopMode.playOnce) { (finished) in
-      if finished == true {
-        self.animationView.currentProgress = finalProgress
-      }
-    }
-  }
-  
-  public override func endTracking(_ touch: UITouch?, with event: UIEvent?) {
-    super.endTracking(touch, with: event)
-    updateOnState(isOn: !_isOn, animated: true, shouldFireHaptics: true)
-    sendActions(for: .valueChanged)
-  }
-  
-  public override func animationDidSet() {
-    updateOnState(isOn: _isOn, animated: true, shouldFireHaptics: false)
+    animationView.play(
+      fromProgress: startProgress,
+      toProgress: endProgress,
+      loopMode: LottieLoopMode.playOnce,
+      completion: { [weak self] finished in
+        guard let self = self else { return }
+
+        // For the Main Thread rendering engine, we freeze the animation at the expected final progress
+        // once the animation is complete. This isn't necessary on the Core Animation engine.
+        if finished, !(self.animationView.animationLayer is CoreAnimationLayer) {
+          self.animationView.currentProgress = finalProgress
+        }
+      })
   }
 
+  // MARK: Fileprivate
+
+  fileprivate var onStartProgress: CGFloat = 0
+  fileprivate var onEndProgress: CGFloat = 1
+  fileprivate var offStartProgress: CGFloat = 1
+  fileprivate var offEndProgress: CGFloat = 0
+  fileprivate var _isOn = false
+  fileprivate var hapticGenerator: ImpactGenerator
+
   // MARK: Private
 
   private func updateAccessibilityLabel() {
     accessibilityValue = _isOn ? NSLocalizedString("On", comment: "On") : NSLocalizedString("Off", comment: "Off")
   }
-  
+
 }
 #endif
 
+// MARK: - ImpactGenerator
+
 protocol ImpactGenerator {
   func generateImpact()
 }
 
+// MARK: - NullHapticGenerator
+
 class NullHapticGenerator: ImpactGenerator {
   func generateImpact() {
-    
+
   }
 }
 
 #if os(iOS)
 @available(iOS 10.0, *)
 class HapticGenerator: ImpactGenerator {
+
+  // MARK: Internal
+
   func generateImpact() {
     impact.impactOccurred()
   }
-  
+
+  // MARK: Fileprivate
+
   fileprivate let impact = UIImpactFeedbackGenerator(style: .light)
 }
 #endif

package/{lottie-swift/src → Sources}/Public/iOS/AnimationSubview.swift

@@ -6,15 +6,15 @@
 //
 
 import Foundation
-#if os(iOS) || os(tvOS) || os(watchOS)
+#if os(iOS) || os(tvOS) || os(watchOS) || targetEnvironment(macCatalyst)
 import UIKit
 
 /// A view that can be added to a keypath of an AnimationView
 public final class AnimationSubview: UIView {
-  
+
   var viewLayer: CALayer? {
-    return layer
+    layer
   }
-  
+
 }
 #endif

package/Sources/Public/iOS/AnimationViewBase.swift

@@ -0,0 +1,78 @@
+//
+//  AnimationViewBase.swift
+//  lottie-swift-iOS
+//
+//  Created by Brandon Withrow on 2/6/19.
+//
+
+#if os(iOS) || os(tvOS) || os(watchOS) || targetEnvironment(macCatalyst)
+import UIKit
+
+/// The base view for `AnimationView` on iOS, tvOS, watchOS, and macCatalyst.
+///
+/// Enables the `AnimationView` implementation to be shared across platforms.
+public class AnimationViewBase: UIView {
+
+  // MARK: Public
+
+  public override var contentMode: UIView.ContentMode {
+    didSet {
+      setNeedsLayout()
+    }
+  }
+
+  public override func didMoveToWindow() {
+    super.didMoveToWindow()
+    animationMovedToWindow()
+  }
+
+  public override func layoutSubviews() {
+    super.layoutSubviews()
+    layoutAnimation()
+  }
+
+  // MARK: Internal
+
+  var viewLayer: CALayer? {
+    layer
+  }
+
+  var screenScale: CGFloat {
+    UIScreen.main.scale
+  }
+
+  func layoutAnimation() {
+    // Implemented by subclasses.
+  }
+
+  func animationMovedToWindow() {
+    // Implemented by subclasses.
+  }
+
+  func commonInit() {
+    contentMode = .scaleAspectFit
+    clipsToBounds = true
+    NotificationCenter.default.addObserver(
+      self,
+      selector: #selector(animationWillEnterForeground),
+      name: UIApplication.willEnterForegroundNotification,
+      object: nil)
+    NotificationCenter.default.addObserver(
+      self,
+      selector: #selector(animationWillMoveToBackground),
+      name: UIApplication.didEnterBackgroundNotification,
+      object: nil)
+  }
+
+  @objc
+  func animationWillMoveToBackground() {
+    // Implemented by subclasses.
+  }
+
+  @objc
+  func animationWillEnterForeground() {
+    // Implemented by subclasses.
+  }
+
+}
+#endif