lottie-ios 3.2.2 → 3.4.1

package/Sources/Private/Model/Text/TextDocument.swift

@@ -0,0 +1,123 @@
+//
+//  TextDocument.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/9/19.
+//
+
+import Foundation
+
+// MARK: - TextJustification
+
+enum TextJustification: Int, Codable {
+  case left
+  case right
+  case center
+}
+
+// MARK: - TextDocument
+
+final class TextDocument: Codable, DictionaryInitializable, AnyInitializable {
+
+  // MARK: Lifecycle
+
+  init(dictionary: [String: Any]) throws {
+    text = try dictionary.value(for: CodingKeys.text)
+    fontSize = try dictionary.value(for: CodingKeys.fontSize)
+    fontFamily = try dictionary.value(for: CodingKeys.fontFamily)
+    let justificationValue: Int = try dictionary.value(for: CodingKeys.justification)
+    guard let justification = TextJustification(rawValue: justificationValue) else {
+      throw InitializableError.invalidInput
+    }
+    self.justification = justification
+    tracking = try dictionary.value(for: CodingKeys.tracking)
+    lineHeight = try dictionary.value(for: CodingKeys.lineHeight)
+    baseline = try dictionary.value(for: CodingKeys.baseline)
+    if let fillColorRawValue = dictionary[CodingKeys.fillColorData.rawValue] {
+      fillColorData = try? Color(value: fillColorRawValue)
+    } else {
+      fillColorData = nil
+    }
+    if let strokeColorRawValue = dictionary[CodingKeys.strokeColorData.rawValue] {
+      strokeColorData = try? Color(value: strokeColorRawValue)
+    } else {
+      strokeColorData = nil
+    }
+    strokeWidth = try? dictionary.value(for: CodingKeys.strokeWidth)
+    strokeOverFill = try? dictionary.value(for: CodingKeys.strokeOverFill)
+    if let textFramePositionRawValue = dictionary[CodingKeys.textFramePosition.rawValue] {
+      textFramePosition = try? Vector3D(value: textFramePositionRawValue)
+    } else {
+      textFramePosition = nil
+    }
+    if let textFrameSizeRawValue = dictionary[CodingKeys.textFrameSize.rawValue] {
+      textFrameSize = try? Vector3D(value: textFrameSizeRawValue)
+    } else {
+      textFrameSize = nil
+    }
+  }
+
+  convenience init(value: Any) throws {
+    guard let dictionary = value as? [String: Any] else {
+      throw InitializableError.invalidInput
+    }
+    try self.init(dictionary: dictionary)
+  }
+
+  // MARK: Internal
+
+  /// The Text
+  let text: String
+
+  /// The Font size
+  let fontSize: Double
+
+  /// The Font Family
+  let fontFamily: String
+
+  /// Justification
+  let justification: TextJustification
+
+  /// Tracking
+  let tracking: Int
+
+  /// Line Height
+  let lineHeight: Double
+
+  /// Baseline
+  let baseline: Double?
+
+  /// Fill Color data
+  let fillColorData: Color?
+
+  /// Scroke Color data
+  let strokeColorData: Color?
+
+  /// Stroke Width
+  let strokeWidth: Double?
+
+  /// Stroke Over Fill
+  let strokeOverFill: Bool?
+
+  let textFramePosition: Vector3D?
+
+  let textFrameSize: Vector3D?
+
+  // MARK: Private
+
+  private enum CodingKeys: String, CodingKey {
+    case text = "t"
+    case fontSize = "s"
+    case fontFamily = "f"
+    case justification = "j"
+    case tracking = "tr"
+    case lineHeight = "lh"
+    case baseline = "ls"
+    case fillColorData = "fc"
+    case strokeColorData = "sc"
+    case strokeWidth = "sw"
+    case strokeOverFill = "of"
+    case textFramePosition = "ps"
+    case textFrameSize = "sz"
+  }
+}

package/Sources/Private/RootAnimationLayer.swift

@@ -0,0 +1,51 @@
+// Created by Cal Stephens on 12/13/21.
+// Copyright © 2021 Airbnb Inc. All rights reserved.
+
+import QuartzCore
+
+// MARK: - RootAnimationLayer
+
+/// A root `CALayer` responsible for playing a Lottie animation
+protocol RootAnimationLayer: CALayer {
+  var currentFrame: AnimationFrameTime { get set }
+  var renderScale: CGFloat { get set }
+  var respectAnimationFrameRate: Bool { get set }
+
+  var _animationLayers: [CALayer] { get }
+  var imageProvider: AnimationImageProvider { get set }
+  var textProvider: AnimationTextProvider { get set }
+  var fontProvider: AnimationFontProvider { get set }
+
+  /// The `CAAnimation` key corresponding to the primary animation.
+  ///  - `AnimationView` uses this key to check if the animation is still active
+  var primaryAnimationKey: AnimationKey { get }
+
+  /// Whether or not this layer is currently playing an animation
+  ///  - If the layer returns `nil`, `AnimationView` determines if an animation
+  ///    is playing by checking if there is an active animation for `primaryAnimationKey`
+  var isAnimationPlaying: Bool? { get }
+
+  /// Instructs this layer to remove all `CAAnimation`s,
+  /// other than the `CAAnimation` managed by `AnimationView` (if applicable)
+  func removeAnimations()
+
+  func reloadImages()
+  func forceDisplayUpdate()
+  func logHierarchyKeypaths()
+
+  func setValueProvider(_ valueProvider: AnyValueProvider, keypath: AnimationKeypath)
+  func getValue(for keypath: AnimationKeypath, atFrame: AnimationFrameTime?) -> Any?
+  func getOriginalValue(for keypath: AnimationKeypath, atFrame: AnimationFrameTime?) -> Any?
+
+  func layer(for keypath: AnimationKeypath) -> CALayer?
+  func animatorNodes(for keypath: AnimationKeypath) -> [AnimatorNode]?
+}
+
+// MARK: - AnimationKey
+
+enum AnimationKey {
+  /// The primary animation and its key should be managed by `AnimationView`
+  case managed
+  /// The primary animation always uses the given key
+  case specific(String)
+}

package/{lottie-swift/src → Sources}/Private/Utility/Debugging/AnimatorNodeDebugging.swift

@@ -8,18 +8,18 @@
 import Foundation
 
 extension AnimatorNode {
-  
+
   func printNodeTree() {
     parentNode?.printNodeTree()
-    print(String(describing: type(of: self)))
-    
+    LottieLogger.shared.info(String(describing: type(of: self)))
+
     if let group = self as? GroupNode {
-      print("* |Children")
+      LottieLogger.shared.info("* |Children")
       group.rootNode?.printNodeTree()
-      print("*")
+      LottieLogger.shared.info("*")
     } else {
-      print("|")
+      LottieLogger.shared.info("|")
     }
   }
-  
+
 }

package/{lottie-swift/src → Sources}/Private/Utility/Debugging/LayerDebugging.swift

@@ -8,6 +8,8 @@
 import Foundation
 import QuartzCore
 
+// MARK: - LayerDebugStyle
+
 struct LayerDebugStyle {
   let anchorColor: CGColor
   let boundsColor: CGColor
@@ -15,14 +17,20 @@ struct LayerDebugStyle {
   let boundsWidth: CGFloat
 }
 
+// MARK: - LayerDebugging
+
 protocol LayerDebugging {
   var debugStyle: LayerDebugStyle { get }
 }
 
+// MARK: - CustomLayerDebugging
+
 protocol CustomLayerDebugging {
   func layerForDebugging() -> CALayer
 }
 
+// MARK: - DebugLayer
+
 class DebugLayer: CALayer {
   init(style: LayerDebugStyle) {
     super.init()
@@ -30,45 +38,48 @@ class DebugLayer: CALayer {
     bounds = CGRect(x: 0, y: 0, width: style.anchorWidth, height: style.anchorWidth)
     backgroundColor = style.anchorColor
   }
-  
-  required init?(coder aDecoder: NSCoder) {
+
+  required init?(coder _: NSCoder) {
     fatalError("init(coder:) has not been implemented")
   }
 }
 
-public extension CALayer {
-  
-  func logLayerTree(withIndent: Int = 0) {
+extension CALayer {
+
+  @nonobjc
+  public func logLayerTree(withIndent: Int = 0) {
     var string = ""
     for _ in 0...withIndent {
       string = string + "  "
     }
     string = string + "|_" + String(describing: self)
-    print(string)
+    LottieLogger.shared.info(string)
     if let sublayers = sublayers {
       for sublayer in sublayers {
         sublayer.logLayerTree(withIndent: withIndent + 1)
       }
     }
   }
-  
+
 }
 
+// MARK: - CompositionLayer + CustomLayerDebugging
+
 extension CompositionLayer: CustomLayerDebugging {
   func layerForDebugging() -> CALayer {
-    return contentsLayer
+    contentsLayer
   }
 }
 
 extension CALayer {
 
+  @nonobjc
   func setDebuggingState(visible: Bool) {
-    
     var sublayers = self.sublayers
     if let cust = self as? CustomLayerDebugging {
       sublayers = cust.layerForDebugging().sublayers
     }
-    
+
     if let sublayers = sublayers {
       for i in 0..<sublayers.count {
         if let debugLayer = sublayers[i] as? DebugLayer {
@@ -77,11 +88,11 @@ extension CALayer {
         }
       }
     }
-    
+
     if let sublayers = sublayers {
       sublayers.forEach({ $0.setDebuggingState(visible: visible) })
     }
-    
+
     if visible {
       let style: LayerDebugStyle
       if let layerDebugging = self as? LayerDebugging {
@@ -105,89 +116,102 @@ extension CALayer {
   }
 }
 
-extension AnimationContainer: LayerDebugging {
+// MARK: - MainThreadAnimationLayer + LayerDebugging
+
+extension MainThreadAnimationLayer: LayerDebugging {
   var debugStyle: LayerDebugStyle {
-    return LayerDebugStyle.topLayerStyle()
+    LayerDebugStyle.topLayerStyle()
   }
 }
 
+// MARK: - NullCompositionLayer + LayerDebugging
+
 extension NullCompositionLayer: LayerDebugging {
   var debugStyle: LayerDebugStyle {
-    return LayerDebugStyle.nullLayerStyle()
+    LayerDebugStyle.nullLayerStyle()
   }
 }
 
+// MARK: - ShapeCompositionLayer + LayerDebugging
+
 extension ShapeCompositionLayer: LayerDebugging {
   var debugStyle: LayerDebugStyle {
-    return LayerDebugStyle.shapeLayerStyle()
+    LayerDebugStyle.shapeLayerStyle()
   }
 }
 
+// MARK: - ShapeRenderLayer + LayerDebugging
+
 extension ShapeRenderLayer: LayerDebugging {
   var debugStyle: LayerDebugStyle {
-    return LayerDebugStyle.shapeRenderLayerStyle()
+    LayerDebugStyle.shapeRenderLayerStyle()
   }
 }
 
 extension LayerDebugStyle {
   static func defaultStyle() -> LayerDebugStyle {
     let colorSpace = CGColorSpaceCreateDeviceRGB()
-    
+
     let anchorColor = CGColor(colorSpace: colorSpace, components: [1, 0, 0, 1])!
     let boundsColor = CGColor(colorSpace: colorSpace, components: [1, 1, 0, 1])!
-    return LayerDebugStyle(anchorColor: anchorColor,
-                           boundsColor: boundsColor,
-                           anchorWidth: 10,
-                           boundsWidth: 2)
+    return LayerDebugStyle(
+      anchorColor: anchorColor,
+      boundsColor: boundsColor,
+      anchorWidth: 10,
+      boundsWidth: 2)
   }
-  
+
   static func topLayerStyle() -> LayerDebugStyle {
     let colorSpace = CGColorSpaceCreateDeviceRGB()
     let anchorColor = CGColor(colorSpace: colorSpace, components: [1, 0.5, 0, 0])!
     let boundsColor = CGColor(colorSpace: colorSpace, components: [0, 1, 0, 1])!
-    
-    return LayerDebugStyle(anchorColor: anchorColor,
-                           boundsColor: boundsColor,
-                           anchorWidth: 10,
-                           boundsWidth: 2)
+
+    return LayerDebugStyle(
+      anchorColor: anchorColor,
+      boundsColor: boundsColor,
+      anchorWidth: 10,
+      boundsWidth: 2)
   }
-  
+
   static func nullLayerStyle() -> LayerDebugStyle {
     let colorSpace = CGColorSpaceCreateDeviceRGB()
     let anchorColor = CGColor(colorSpace: colorSpace, components: [0, 0, 1, 0])!
     let boundsColor = CGColor(colorSpace: colorSpace, components: [0, 1, 0, 1])!
-    
-    return LayerDebugStyle(anchorColor: anchorColor,
-                           boundsColor: boundsColor,
-                           anchorWidth: 10,
-                           boundsWidth: 2)
+
+    return LayerDebugStyle(
+      anchorColor: anchorColor,
+      boundsColor: boundsColor,
+      anchorWidth: 10,
+      boundsWidth: 2)
   }
-  
+
   static func shapeLayerStyle() -> LayerDebugStyle {
     let colorSpace = CGColorSpaceCreateDeviceRGB()
     let anchorColor = CGColor(colorSpace: colorSpace, components: [0, 1, 0, 0])!
     let boundsColor = CGColor(colorSpace: colorSpace, components: [0, 1, 0, 1])!
-    
-    return LayerDebugStyle(anchorColor: anchorColor,
-                           boundsColor: boundsColor,
-                           anchorWidth: 10,
-                           boundsWidth: 2)
+
+    return LayerDebugStyle(
+      anchorColor: anchorColor,
+      boundsColor: boundsColor,
+      anchorWidth: 10,
+      boundsWidth: 2)
   }
-  
+
   static func shapeRenderLayerStyle() -> LayerDebugStyle {
     let colorSpace = CGColorSpaceCreateDeviceRGB()
     let anchorColor = CGColor(colorSpace: colorSpace, components: [0, 1, 1, 0])!
     let boundsColor = CGColor(colorSpace: colorSpace, components: [0, 1, 0, 1])!
-    
-    return LayerDebugStyle(anchorColor: anchorColor,
-                           boundsColor: boundsColor,
-                           anchorWidth: 10,
-                           boundsWidth: 2)
+
+    return LayerDebugStyle(
+      anchorColor: anchorColor,
+      boundsColor: boundsColor,
+      anchorWidth: 10,
+      boundsWidth: 2)
   }
 }
 
 extension Array where Element == LayerModel {
-  
+
   var parents: [Int] {
     var array = [Int]()
     for layer in self {
@@ -199,5 +223,5 @@ extension Array where Element == LayerModel {
     }
     return array
   }
- 
+
 }

package/Sources/Private/Utility/Debugging/TestHelpers.swift

@@ -0,0 +1,10 @@
+// Created by Cal Stephens on 1/28/22.
+// Copyright © 2022 Airbnb Inc. All rights reserved.
+
+enum TestHelpers {
+  /// Whether or not snapshot tests are currently running in a test target
+  static var snapshotTestsAreRunning = false
+
+  /// Whether or not performance tests are currently running in a test target
+  static var performanceTestsAreRunning = false
+}