lottie-ios 3.2.3 → 3.4.2

package/Sources/Private/CoreAnimation/Layers/SolidLayer.swift

@@ -0,0 +1,47 @@
+// Created by Cal Stephens on 12/13/21.
+// Copyright © 2021 Airbnb Inc. All rights reserved.
+
+import QuartzCore
+
+// MARK: - SolidLayer
+
+final class SolidLayer: BaseCompositionLayer {
+
+  // MARK: Lifecycle
+
+  init(_ solidLayer: SolidLayerModel) {
+    self.solidLayer = solidLayer
+    super.init(layerModel: solidLayer)
+    setupContentLayer()
+  }
+
+  required init?(coder _: NSCoder) {
+    fatalError("init(coder:) has not been implemented")
+  }
+
+  /// Called by CoreAnimation to create a shadow copy of this layer
+  /// More details: https://developer.apple.com/documentation/quartzcore/calayer/1410842-init
+  override init(layer: Any) {
+    guard let typedLayer = layer as? Self else {
+      fatalError("\(Self.self).init(layer:) incorrectly called with \(type(of: layer))")
+    }
+
+    solidLayer = typedLayer.solidLayer
+    super.init(layer: typedLayer)
+  }
+
+  // MARK: Private
+
+  private let solidLayer: SolidLayerModel
+
+  private func setupContentLayer() {
+    // Render the fill color in a child `CAShapeLayer`
+    //  - Using a `CAShapeLayer` specifically, instead of a `CALayer` with a `backgroundColor`,
+    //    allows the size of the fill shape to be different from `contentsLayer.size`.
+    let shapeLayer = CAShapeLayer()
+    shapeLayer.fillColor = solidLayer.colorHex.cgColor
+    shapeLayer.path = CGPath(rect: .init(x: 0, y: 0, width: solidLayer.width, height: solidLayer.height), transform: nil)
+    addSublayer(shapeLayer)
+  }
+
+}

package/Sources/Private/CoreAnimation/Layers/TextLayer.swift

@@ -0,0 +1,91 @@
+// Created by Cal Stephens on 2/9/22.
+// Copyright © 2022 Airbnb Inc. All rights reserved.
+
+import QuartzCore
+
+/// The `CALayer` type responsible for rendering `TextLayer`s
+final class TextLayer: BaseCompositionLayer {
+
+  // MARK: Lifecycle
+
+  init(
+    textLayerModel: TextLayerModel,
+    context: LayerContext)
+    throws
+  {
+    self.textLayerModel = textLayerModel
+    super.init(layerModel: textLayerModel)
+    setupSublayers()
+    try configureRenderLayer(with: context)
+  }
+
+  required init?(coder _: NSCoder) {
+    fatalError("init(coder:) has not been implemented")
+  }
+
+  /// Called by CoreAnimation to create a shadow copy of this layer
+  /// More details: https://developer.apple.com/documentation/quartzcore/calayer/1410842-init
+  override init(layer: Any) {
+    guard let typedLayer = layer as? Self else {
+      fatalError("\(Self.self).init(layer:) incorrectly called with \(type(of: layer))")
+    }
+
+    textLayerModel = typedLayer.textLayerModel
+    super.init(layer: typedLayer)
+  }
+
+  // MARK: Internal
+
+  func configureRenderLayer(with context: LayerContext) throws {
+    // We can't use `CATextLayer`, because it doesn't support enough features we use.
+    // Instead, we use the same `CoreTextRenderLayer` (with a custom `draw` implementation)
+    // used by the Main Thread rendering engine. This means the Core Animation engine can't
+    // _animate_ text properties, but it can display static text without any issues.
+    let text = try textLayerModel.text.exactlyOneKeyframe(context: context, description: "text layer text")
+
+    // The Core Animation engine doesn't currently support `TextAnimator`s.
+    //  - We could add support for animating the transform-related properties without much trouble.
+    //  - We may be able to support animating `fillColor` by getting clever with layer blend modes
+    //    or masks (e.g. use `CoreTextRenderLayer` to draw black glyphs, and then fill them in
+    //    using a `CAShapeLayer`).
+    if !textLayerModel.animators.isEmpty {
+      try context.logCompatibilityIssue("""
+        The Core Animation rendering engine currently doesn't support text animators.
+        """)
+    }
+
+    renderLayer.text = text.text
+    renderLayer.font = context.fontProvider.fontFor(family: text.fontFamily, size: CGFloat(text.fontSize))
+
+    renderLayer.alignment = text.justification.textAlignment
+    renderLayer.lineHeight = CGFloat(text.lineHeight)
+    renderLayer.tracking = (CGFloat(text.fontSize) * CGFloat(text.tracking)) / 1000
+
+    renderLayer.fillColor = text.fillColorData?.cgColorValue
+    renderLayer.strokeColor = text.strokeColorData?.cgColorValue
+    renderLayer.strokeWidth = CGFloat(text.strokeWidth ?? 0)
+    renderLayer.strokeOnTop = text.strokeOverFill ?? false
+
+    renderLayer.preferredSize = text.textFrameSize?.sizeValue
+    renderLayer.sizeToFit()
+
+    renderLayer.transform = CATransform3DIdentity
+    renderLayer.position = text.textFramePosition?.pointValue ?? .zero
+  }
+
+  // MARK: Private
+
+  private let textLayerModel: TextLayerModel
+  private let renderLayer = CoreTextRenderLayer()
+
+  private func setupSublayers() {
+    // Place the text render layer in an additional container
+    //  - Direct sublayers of a `BaseCompositionLayer` always fill the bounds
+    //    of their superlayer -- so this container will be the bounds of self,
+    //    and the text render layer can be positioned anywhere.
+    let textContainerLayer = CALayer()
+    textContainerLayer.addSublayer(renderLayer)
+    addSublayer(textContainerLayer)
+  }
+
+}

package/Sources/Private/CoreAnimation/Layers/TransformLayer.swift

@@ -0,0 +1,11 @@
+// Created by Cal Stephens on 12/21/21.
+// Copyright © 2021 Airbnb Inc. All rights reserved.
+
+/// The CALayer type responsible for only rendering the `transform` of a `LayerModel`
+final class TransformLayer: BaseCompositionLayer {
+
+  /// `TransformLayer`s don't render any visible content,
+  /// they just `transform` their sublayers
+  override var renderLayerContents: Bool { false }
+
+}

package/Sources/Private/CoreAnimation/ValueProviderStore.swift

@@ -0,0 +1,139 @@
+// Created by Cal Stephens on 1/13/22.
+// Copyright © 2022 Airbnb Inc. All rights reserved.
+
+import QuartzCore
+
+// MARK: - ValueProviderStore
+
+/// Registration and storage for `AnyValueProvider`s that can dynamically
+/// provide custom values for `AnimationKeypath`s within an `Animation`.
+final class ValueProviderStore {
+
+  // MARK: Lifecycle
+
+  init(logger: LottieLogger) {
+    self.logger = logger
+  }
+
+  // MARK: Internal
+
+  /// Registers an `AnyValueProvider` for the given `AnimationKeypath`
+  func setValueProvider(_ valueProvider: AnyValueProvider, keypath: AnimationKeypath) {
+    logger.assert(
+      valueProvider.typeErasedStorage.isSupportedByCoreAnimationRenderingEngine,
+      """
+      The Core Animation rendering engine doesn't support Value Providers that vend a closure,
+      because that would require calling the closure on the main thread once per frame.
+      """)
+
+    // TODO: Support more value types
+    logger.assert(
+      keypath.keys.last == PropertyName.color.rawValue,
+      "The Core Animation rendering engine currently only supports customizing color values")
+
+    valueProviders.append((keypath: keypath, valueProvider: valueProvider))
+  }
+
+  // Retrieves the custom value keyframes for the given property,
+  // if an `AnyValueProvider` was registered for the given keypath.
+  func customKeyframes<Value>(
+    of customizableProperty: CustomizableProperty<Value>,
+    for keypath: AnimationKeypath,
+    context: LayerAnimationContext)
+    throws
+    -> KeyframeGroup<Value>?
+  {
+    if context.logHierarchyKeypaths {
+      context.logger.info(keypath.fullPath)
+    }
+
+    guard let anyValueProvider = valueProvider(for: keypath) else {
+      return nil
+    }
+
+    // Retrieve the type-erased keyframes from the custom `ValueProvider`
+    let typeErasedKeyframes: [Keyframe<Any>]
+    switch anyValueProvider.typeErasedStorage {
+    case .singleValue(let typeErasedValue):
+      typeErasedKeyframes = [Keyframe(typeErasedValue)]
+
+    case .keyframes(let keyframes, _):
+      typeErasedKeyframes = keyframes
+
+    case .closure:
+      try context.logCompatibilityIssue("""
+        The Core Animation rendering engine doesn't support Value Providers that vend a closure,
+        because that would require calling the closure on the main thread once per frame.
+        """)
+      return nil
+    }
+
+    // Convert the type-erased keyframe values using this `CustomizableProperty`'s conversion closure
+    let typedKeyframes = typeErasedKeyframes.compactMap { typeErasedKeyframe -> Keyframe<Value>? in
+      guard let convertedValue = customizableProperty.conversion(typeErasedKeyframe.value) else {
+        logger.assertionFailure("""
+          Could not convert value of type \(type(of: typeErasedKeyframe.value)) to expected type \(Value.self)
+          """)
+        return nil
+      }
+
+      return typeErasedKeyframe.withValue(convertedValue)
+    }
+
+    // Verify that all of the keyframes were successfully converted to the expected type
+    guard typedKeyframes.count == typeErasedKeyframes.count else {
+      return nil
+    }
+
+    return KeyframeGroup(keyframes: ContiguousArray(typedKeyframes))
+  }
+
+  // MARK: Private
+
+  private let logger: LottieLogger
+
+  private var valueProviders = [(keypath: AnimationKeypath, valueProvider: AnyValueProvider)]()
+
+  /// Retrieves the most-recently-registered Value Provider that matches the given keypat
+  private func valueProvider(for keypath: AnimationKeypath) -> AnyValueProvider? {
+    // Find the last keypath matching the given keypath,
+    // so we return the value provider that was registered most-recently
+    valueProviders.last(where: { registeredKeypath, _ in
+      keypath.matches(registeredKeypath)
+    })?.valueProvider
+  }
+
+}
+
+extension AnyValueProviderStorage {
+  /// Whether or not this type of value provider is supported
+  /// by the new Core Animation rendering engine
+  var isSupportedByCoreAnimationRenderingEngine: Bool {
+    switch self {
+    case .singleValue, .keyframes:
+      return true
+    case .closure:
+      return false
+    }
+  }
+}
+
+extension AnimationKeypath {
+  /// Whether or not this keypath from the animation hierarchy
+  /// matches the given keypath (which may contain wildcards)
+  func matches(_ keypath: AnimationKeypath) -> Bool {
+    var regex = "^" // match the start of the string
+      + keypath.keys.joined(separator: "\\.") // match this keypath, escaping "." characters
+      + "$" // match the end of the string
+
+    // ** wildcards match anything
+    //  - "**.Color" matches both "Layer 1.Color" and "Layer 1.Layer 2.Color"
+    regex = regex.replacingOccurrences(of: "**", with: ".+")
+
+    // * wildcards match any individual path component
+    //  - "*.Color" matches "Layer 1.Color" but not "Layer 1.Layer 2.Color"
+    regex = regex.replacingOccurrences(of: "*", with: "[^.]+")
+
+    return fullPath.range(of: regex, options: .regularExpression) != nil
+  }
+}

package/{lottie-swift/src/Private → Sources/Private/MainThread}/LayerContainers/CompLayers/CompositionLayer.swift

@@ -8,70 +8,37 @@
 import Foundation
 import QuartzCore
 
-/**
- The base class for a child layer of CompositionContainer
- */
+// MARK: - CompositionLayer
+
+/// The base class for a child layer of CompositionContainer
 class CompositionLayer: CALayer, KeypathSearchable {
-  
-  weak var layerDelegate: CompositionLayerDelegate?
-  
-  let transformNode: LayerTransformNode
-  
-  let contentsLayer: CALayer = CALayer()
-  
-  let maskLayer: MaskContainerLayer?
-  
-  let matteType: MatteType?
-  
-  var renderScale: CGFloat = 1 {
-    didSet {
-      self.updateRenderScale()
-    }
-  }
-  
-  var matteLayer: CompositionLayer? {
-    didSet {
-      if let matte = matteLayer {
-        if let type = matteType, type == .invert {
-          mask = InvertedMatteLayer(inputMatte: matte)
-        } else {
-          mask = matte
-        }
-      } else {
-        mask = nil
-      }
-    }
-  }
-  
-  let inFrame: CGFloat
-  let outFrame: CGFloat
-  let startFrame: CGFloat
-  let timeStretch: CGFloat
-  
+
+  // MARK: Lifecycle
+
   init(layer: LayerModel, size: CGSize) {
-    self.transformNode = LayerTransformNode(transform: layer.transform)
-    if let masks = layer.masks {
+    transformNode = LayerTransformNode(transform: layer.transform)
+    if let masks = layer.masks?.filter({ $0.mode != .none }), !masks.isEmpty {
       maskLayer = MaskContainerLayer(masks: masks)
     } else {
       maskLayer = nil
     }
-    self.matteType = layer.matte
-    self.inFrame = layer.inFrame.cgFloat
-    self.outFrame = layer.outFrame.cgFloat
-    self.timeStretch = layer.timeStretch.cgFloat
-    self.startFrame = layer.startTime.cgFloat
-    self.keypathName = layer.name
-    self.childKeypaths = [transformNode.transformProperties]
+    matteType = layer.matte
+    inFrame = layer.inFrame.cgFloat
+    outFrame = layer.outFrame.cgFloat
+    timeStretch = layer.timeStretch.cgFloat
+    startFrame = layer.startTime.cgFloat
+    keypathName = layer.name
+    childKeypaths = [transformNode.transformProperties]
     super.init()
-    self.anchorPoint = .zero
-    self.actions = [
+    anchorPoint = .zero
+    actions = [
       "opacity" : NSNull(),
       "transform" : NSNull(),
       "bounds" : NSNull(),
       "anchorPoint" : NSNull(),
-      "sublayerTransform" : NSNull()
+      "sublayerTransform" : NSNull(),
     ]
-    
+
     contentsLayer.anchorPoint = .zero
     contentsLayer.bounds = CGRect(origin: .zero, size: size)
     contentsLayer.actions = [
@@ -80,36 +47,90 @@ class CompositionLayer: CALayer, KeypathSearchable {
       "bounds" : NSNull(),
       "anchorPoint" : NSNull(),
       "sublayerTransform" : NSNull(),
-      "hidden" : NSNull()
+      "hidden" : NSNull(),
     ]
+    compositingFilter = layer.blendMode.filterName
     addSublayer(contentsLayer)
-    
+
     if let maskLayer = maskLayer {
       contentsLayer.mask = maskLayer
     }
+
+    name = layer.name
   }
-  
+
   override init(layer: Any) {
     /// Used for creating shadow model layers. Read More here: https://developer.apple.com/documentation/quartzcore/calayer/1410842-init
     guard let layer = layer as? CompositionLayer else {
       fatalError("Wrong Layer Class")
     }
-    self.transformNode = layer.transformNode
-    self.matteType = layer.matteType
-    self.inFrame = layer.inFrame
-    self.outFrame = layer.outFrame
-    self.timeStretch = layer.timeStretch
-    self.startFrame = layer.startFrame
-    self.keypathName = layer.keypathName
-    self.childKeypaths = [transformNode.transformProperties]
-    self.maskLayer = nil
+    transformNode = layer.transformNode
+    matteType = layer.matteType
+    inFrame = layer.inFrame
+    outFrame = layer.outFrame
+    timeStretch = layer.timeStretch
+    startFrame = layer.startFrame
+    keypathName = layer.keypathName
+    childKeypaths = [transformNode.transformProperties]
+    maskLayer = nil
     super.init(layer: layer)
   }
-  
-  required init?(coder aDecoder: NSCoder) {
+
+  required init?(coder _: NSCoder) {
     fatalError("init(coder:) has not been implemented")
   }
-  
+
+  // MARK: Internal
+
+  weak var layerDelegate: CompositionLayerDelegate?
+
+  let transformNode: LayerTransformNode
+
+  let contentsLayer = CALayer()
+
+  let maskLayer: MaskContainerLayer?
+
+  let matteType: MatteType?
+
+  let inFrame: CGFloat
+  let outFrame: CGFloat
+  let startFrame: CGFloat
+  let timeStretch: CGFloat
+
+  // MARK: Keypath Searchable
+
+  let keypathName: String
+
+  final var childKeypaths: [KeypathSearchable]
+
+  var renderScale: CGFloat = 1 {
+    didSet {
+      updateRenderScale()
+    }
+  }
+
+  var matteLayer: CompositionLayer? {
+    didSet {
+      if let matte = matteLayer {
+        if let type = matteType, type == .invert {
+          mask = InvertedMatteLayer(inputMatte: matte)
+        } else {
+          mask = matte
+        }
+      } else {
+        mask = nil
+      }
+    }
+  }
+
+  var keypathProperties: [String: AnyNodeProperty] {
+    [:]
+  }
+
+  var keypathLayer: CALayer? {
+    contentsLayer
+  }
+
   final func displayWithFrame(frame: CGFloat, forceUpdates: Bool) {
     transformNode.updateTree(frame, forceUpdates: forceUpdates)
     let layerVisible = frame.isInRangeOrEqual(inFrame, outFrame)
@@ -123,31 +144,18 @@ class CompositionLayer: CALayer, KeypathSearchable {
     contentsLayer.isHidden = !layerVisible
     layerDelegate?.frameUpdated(frame: frame)
   }
-  
-  func displayContentsWithFrame(frame: CGFloat, forceUpdates: Bool) {
+
+  func displayContentsWithFrame(frame _: CGFloat, forceUpdates _: Bool) {
     /// To be overridden by subclass
   }
-  
-  // MARK: Keypath Searchable
-  
-  let keypathName: String
-  
-  var keypathProperties: [String : AnyNodeProperty] {
-    return [:]
-  }
-  
-  final var childKeypaths: [KeypathSearchable]
-  
-  var keypathLayer: CALayer? {
-    return contentsLayer
-  }
-  
+
   func updateRenderScale() {
-    /// To be overridden by subclass
+    contentsScale = renderScale
   }
 }
 
+// MARK: - CompositionLayerDelegate
+
 protocol CompositionLayerDelegate: AnyObject {
   func frameUpdated(frame: CGFloat)
 }
-

package/{lottie-swift/src/Private → Sources/Private/MainThread}/LayerContainers/CompLayers/ImageCompositionLayer.swift

@@ -5,43 +5,46 @@
 //  Created by Brandon Withrow on 1/25/19.
 //
 
-import Foundation
 import CoreGraphics
+import Foundation
 import QuartzCore
 
 final class ImageCompositionLayer: CompositionLayer {
-  
-  var image: CGImage? = nil {
-    didSet {
-      if let image = image {
-        contentsLayer.contents = image
-      } else {
-        contentsLayer.contents = nil
-      }
-    }
-  }
-  
-  let imageReferenceID: String
-  
+
+  // MARK: Lifecycle
+
   init(imageLayer: ImageLayerModel, size: CGSize) {
-    self.imageReferenceID = imageLayer.referenceID
+    imageReferenceID = imageLayer.referenceID
     super.init(layer: imageLayer, size: size)
     contentsLayer.masksToBounds = true
     contentsLayer.contentsGravity = CALayerContentsGravity.resize
   }
-  
+
   override init(layer: Any) {
     /// Used for creating shadow model layers. Read More here: https://developer.apple.com/documentation/quartzcore/calayer/1410842-init
     guard let layer = layer as? ImageCompositionLayer else {
       fatalError("init(layer:) Wrong Layer Class")
     }
-    self.imageReferenceID = layer.imageReferenceID
-    self.image = nil
+    imageReferenceID = layer.imageReferenceID
+    image = nil
     super.init(layer: layer)
   }
-  
-  required init?(coder aDecoder: NSCoder) {
+
+  required init?(coder _: NSCoder) {
     fatalError("init(coder:) has not been implemented")
   }
-  
+
+  // MARK: Internal
+
+  let imageReferenceID: String
+
+  var image: CGImage? = nil {
+    didSet {
+      if let image = image {
+        contentsLayer.contents = image
+      } else {
+        contentsLayer.contents = nil
+      }
+    }
+  }
 }