lottie-ios 3.2.2 → 3.4.1

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

@@ -0,0 +1,138 @@
+// Created by Cal Stephens on 1/6/22.
+// Copyright © 2022 Airbnb Inc. All rights reserved.
+
+import QuartzCore
+
+// MARK: - MaskCompositionLayer
+
+/// The CALayer type responsible for rendering the `Mask` of a `BaseCompositionLayer`
+final class MaskCompositionLayer: CALayer {
+
+  // MARK: Lifecycle
+
+  init(masks: [Mask]) {
+    maskLayers = masks.map(MaskLayer.init(mask:))
+    super.init()
+
+    var containerLayer = BaseAnimationLayer()
+    var firstObject = true
+    for maskLayer in maskLayers {
+      if maskLayer.maskModel.mode.usableMode == .none {
+        continue
+      } else if maskLayer.maskModel.mode.usableMode == .add || firstObject {
+        firstObject = false
+        containerLayer.addSublayer(maskLayer)
+      } else {
+        containerLayer.mask = maskLayer
+        let newContainer = BaseAnimationLayer()
+        newContainer.addSublayer(containerLayer)
+        containerLayer = newContainer
+      }
+    }
+
+    addSublayer(containerLayer)
+  }
+
+  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))")
+    }
+
+    maskLayers = typedLayer.maskLayers
+    super.init(layer: typedLayer)
+  }
+
+  // MARK: Internal
+
+  override func layoutSublayers() {
+    super.layoutSublayers()
+
+    for sublayer in sublayers ?? [] {
+      sublayer.fillBoundsOfSuperlayer()
+    }
+  }
+
+  // MARK: Private
+
+  private let maskLayers: [MaskLayer]
+
+}
+
+// MARK: AnimationLayer
+
+extension MaskCompositionLayer: AnimationLayer {
+  func setupAnimations(context: LayerAnimationContext) throws {
+    for maskLayer in maskLayers {
+      try maskLayer.setupAnimations(context: context)
+    }
+  }
+}
+
+// MARK: - MaskLayer
+
+extension MaskCompositionLayer {
+  final class MaskLayer: CAShapeLayer {
+
+    // MARK: Lifecycle
+
+    init(mask: Mask) {
+      maskModel = mask
+      super.init()
+
+      fillRule = .evenOdd
+    }
+
+    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))")
+      }
+
+      maskModel = typedLayer.maskModel
+      super.init(layer: typedLayer)
+    }
+
+    // MARK: Internal
+
+    let maskModel: Mask
+
+  }
+}
+
+// MARK: - MaskCompositionLayer.MaskLayer + AnimationLayer
+
+extension MaskCompositionLayer.MaskLayer: AnimationLayer {
+  func setupAnimations(context: LayerAnimationContext) throws {
+    let shouldInvertMask = (maskModel.mode.usableMode == .subtract && !maskModel.inverted)
+      || (maskModel.mode.usableMode == .add && maskModel.inverted)
+
+    try addAnimations(
+      for: maskModel.shape,
+      context: context,
+      transformPath: { maskPath in
+        // If the mask is using `MaskMode.subtract` or has `inverted: true`,
+        // we have to invert the area filled by the path. We can do that by
+        // drawing a rectangle, and then adding a path (which is subtracted
+        // from the rectangle based on the .evenOdd fill mode).
+        if shouldInvertMask {
+          let path = CGMutablePath()
+          path.addRect(.veryLargeRect)
+          path.addPath(maskPath)
+          return path
+        } else {
+          return maskPath
+        }
+      })
+  }
+}

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

@@ -0,0 +1,140 @@
+// Created by Cal Stephens on 12/14/21.
+// Copyright © 2021 Airbnb Inc. All rights reserved.
+
+import QuartzCore
+
+// MARK: - PreCompLayer
+
+/// The `CALayer` type responsible for rendering `PreCompLayerModel`s
+final class PreCompLayer: BaseCompositionLayer {
+
+  // MARK: Lifecycle
+
+  init(preCompLayer: PreCompLayerModel) {
+    self.preCompLayer = preCompLayer
+    super.init(layerModel: preCompLayer)
+  }
+
+  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))")
+    }
+
+    preCompLayer = typedLayer.preCompLayer
+    timeRemappingInterpolator = typedLayer.timeRemappingInterpolator
+    super.init(layer: typedLayer)
+  }
+
+  // MARK: Internal
+
+  /// Post-init setup for `PreCompLayer`s.
+  /// Should always be called after `PreCompLayer.init(preCompLayer:)`.
+  ///
+  /// This is a workaround for a hard-to-reproduce crash that was
+  /// triggered when `PreCompLayer.init` was called reentantly. We didn't
+  /// have any consistent repro steps for this crash (it happened 100% of
+  /// the time for some testers, and 0% of the time for other testers),
+  /// but moving this code out of `PreCompLayer.init` does seem to fix it.
+  ///
+  /// The stack trace looked like:
+  ///  - `_os_unfair_lock_recursive_abort`
+  ///  - `-[CALayerAccessibility__UIKit__QuartzCore dealloc]`
+  ///  - `PreCompLayer.__allocating_init(preCompLayer:context:)` <- reentrant init call
+  ///  - ...
+  ///  - `CALayer.setupLayerHierarchy(for:context:)`
+  ///  - `PreCompLayer.init(preCompLayer:context:)`
+  ///
+  func setup(context: LayerContext) throws {
+    if let timeRemappingKeyframes = preCompLayer.timeRemapping {
+      timeRemappingInterpolator = try .timeRemapping(keyframes: timeRemappingKeyframes, context: context)
+    } else {
+      timeRemappingInterpolator = nil
+    }
+
+    try setupLayerHierarchy(
+      for: context.animation.assetLibrary?.precompAssets[preCompLayer.referenceID]?.layers ?? [],
+      context: context)
+  }
+
+  override func setupAnimations(context: LayerAnimationContext) throws {
+    var context = context
+    context = context.addingKeypathComponent(preCompLayer.name)
+    try setupLayerAnimations(context: context)
+
+    // Precomp layers can adjust the local time of their child layers (relative to the
+    // animation's global time) via `timeRemapping` or a custom `startTime`
+    let contextForChildren = context.withTimeRemapping { [preCompLayer, timeRemappingInterpolator] layerLocalFrame in
+      if let timeRemappingInterpolator = timeRemappingInterpolator {
+        return timeRemappingInterpolator.value(frame: layerLocalFrame) as? AnimationFrameTime ?? layerLocalFrame
+      } else {
+        return layerLocalFrame + AnimationFrameTime(preCompLayer.startTime)
+      }
+    }
+
+    try setupChildAnimations(context: contextForChildren)
+  }
+
+  // MARK: Private
+
+  private let preCompLayer: PreCompLayerModel
+  private var timeRemappingInterpolator: KeyframeInterpolator<AnimationFrameTime>?
+
+}
+
+// MARK: CustomLayoutLayer
+
+extension PreCompLayer: CustomLayoutLayer {
+  func layout(superlayerBounds: CGRect) {
+    anchorPoint = .zero
+
+    // Pre-comp layers use a size specified in the layer model,
+    // and clip the composition to that bounds
+    bounds = CGRect(
+      x: superlayerBounds.origin.x,
+      y: superlayerBounds.origin.y,
+      width: CGFloat(preCompLayer.width),
+      height: CGFloat(preCompLayer.height))
+
+    masksToBounds = true
+  }
+}
+
+extension KeyframeInterpolator where ValueType == AnimationFrameTime {
+  /// A `KeyframeInterpolator` for the given `timeRemapping` keyframes
+  static func timeRemapping(
+    keyframes timeRemappingKeyframes: KeyframeGroup<Vector1D>,
+    context: LayerContext)
+    throws
+    -> KeyframeInterpolator<AnimationFrameTime>
+  {
+    try context.logCompatibilityIssue("""
+      The Core Animation rendering engine partially supports time remapping keyframes,
+      but this is somewhat experimental and has some known issues. Since it doesn't work
+      in all cases, we have to fall back to using the main thread engine when using
+      `RenderingEngineOption.automatic`.
+      """)
+
+    // `timeRemapping` is a mapping from the animation's global time to the layer's local time.
+    // In the Core Animation engine, we need to perform the opposite calculation -- convert
+    // the layer's local time into the animation's global time. We can get this by inverting
+    // the time remapping, swapping the x axis (global time) and the y axis (local time).
+    let localTimeToGlobalTimeMapping = timeRemappingKeyframes.keyframes.map { keyframe in
+      Keyframe(
+        value: keyframe.time,
+        time: keyframe.value.cgFloatValue * CGFloat(context.animation.framerate),
+        isHold: keyframe.isHold,
+        inTangent: keyframe.inTangent,
+        outTangent: keyframe.outTangent,
+        spatialInTangent: keyframe.spatialInTangent,
+        spatialOutTangent: keyframe.spatialOutTangent)
+    }
+
+    return KeyframeInterpolator(keyframes: .init(localTimeToGlobalTimeMapping))
+  }
+}

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

@@ -0,0 +1,302 @@
+// Created by Cal Stephens on 12/13/21.
+// Copyright © 2021 Airbnb Inc. All rights reserved.
+
+import QuartzCore
+
+// MARK: - ShapeItemLayer
+
+/// A CALayer type that renders an array of `[ShapeItem]`s,
+/// from a `Group` in a `ShapeLayerModel`.
+final class ShapeItemLayer: BaseAnimationLayer {
+
+  // MARK: Lifecycle
+
+  /// Initializes a `ShapeItemLayer` that renders a `Group` from a `ShapeLayerModel`
+  /// - Parameters:
+  ///   - shape: The `ShapeItem` in this group that renders a `GGPath`
+  ///   - otherItems: Other items in this group that affect the appearance of the shape
+  init(shape: Item, otherItems: [Item], context: LayerContext) throws {
+    self.shape = shape
+    self.otherItems = otherItems
+
+    try context.compatibilityAssert(
+      shape.item.drawsCGPath,
+      "`ShapeItemLayer` must contain exactly one `ShapeItem` that draws a `GPPath`")
+
+    try context.compatibilityAssert(
+      !otherItems.contains(where: { $0.item.drawsCGPath }),
+      "`ShapeItemLayer` must contain exactly one `ShapeItem` that draws a `GPPath`")
+
+    super.init()
+
+    setupLayerHierarchy()
+  }
+
+  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))")
+    }
+
+    shape = typedLayer.shape
+    otherItems = typedLayer.otherItems
+    super.init(layer: typedLayer)
+  }
+
+  // MARK: Internal
+
+  /// An item that can be displayed by this layer
+  struct Item {
+    /// A `ShapeItem` that should be rendered by this layer
+    let item: ShapeItem
+
+    /// The group that contains this `ShapeItem`, if applicable
+    let parentGroup: Group?
+  }
+
+  override func setupAnimations(context: LayerAnimationContext) throws {
+    try super.setupAnimations(context: context)
+
+    guard let sublayerConfiguration = sublayerConfiguration else { return }
+
+    switch sublayerConfiguration.fill {
+    case .solidFill(let shapeLayer):
+      try setupSolidFillAnimations(shapeLayer: shapeLayer, context: context)
+
+    case .gradientFill(let gradientLayers):
+      try setupGradientFillAnimations(layers: gradientLayers, context: context)
+    }
+
+    if let gradientStrokeConfiguration = sublayerConfiguration.gradientStroke {
+      try setupGradientStrokeAnimations(layers: gradientStrokeConfiguration, context: context)
+    }
+  }
+
+  // MARK: Private
+
+  private struct GradientLayers {
+    /// The `CALayer` that renders the RGB components of the gradient
+    let gradientColorLayer: GradientRenderLayer
+    /// The `CALayer` that renders the alpha components of the gradient,
+    /// masking the `gradientColorLayer`
+    let gradientAlphaLayer: GradientRenderLayer?
+    /// The `CAShapeLayer` that clips the gradient layers to the expected shape
+    let shapeMaskLayer: CAShapeLayer
+  }
+
+  /// The configuration of this layer's `fill` sublayers
+  private enum FillLayerConfiguration {
+    /// This layer displays a single `CAShapeLayer`
+    case solidFill(CAShapeLayer)
+
+    /// This layer displays a `GradientRenderLayer` masked by a `CAShapeLayer`.
+    case gradientFill(GradientLayers)
+  }
+
+  /// The `ShapeItem` in this group that renders a `GGPath`
+  private let shape: Item
+
+  /// Other items in this group that affect the appearance of the shape
+  private let otherItems: [Item]
+
+  /// The current configuration of this layer's sublayer(s)
+  private var sublayerConfiguration: (fill: FillLayerConfiguration, gradientStroke: GradientLayers?)?
+
+  private func setupLayerHierarchy() {
+    // We have to build a different layer hierarchy depending on if
+    // we're rendering a gradient (a `CAGradientLayer` masked by a `CAShapeLayer`)
+    // or a solid shape (a simple `CAShapeLayer`).
+    let fillLayerConfiguration: FillLayerConfiguration
+    if let gradientFill = otherItems.first(GradientFill.self) {
+      fillLayerConfiguration = setupGradientFillLayerHierarchy(for: gradientFill)
+    } else {
+      fillLayerConfiguration = setupSolidFillLayerHierarchy()
+    }
+
+    let gradientStrokeConfiguration: GradientLayers?
+    if let gradientStroke = otherItems.first(GradientStroke.self) {
+      gradientStrokeConfiguration = setupGradientStrokeLayerHierarchy(for: gradientStroke)
+    } else {
+      gradientStrokeConfiguration = nil
+    }
+
+    sublayerConfiguration = (fillLayerConfiguration, gradientStrokeConfiguration)
+  }
+
+  private func setupSolidFillLayerHierarchy() -> FillLayerConfiguration {
+    let shapeLayer = CAShapeLayer()
+    addSublayer(shapeLayer)
+
+    // `CAShapeLayer.fillColor` defaults to black, so we have to
+    // nil out the background color if there isn't an expected fill color
+    if !otherItems.contains(where: { $0.item is Fill }) {
+      shapeLayer.fillColor = nil
+    }
+
+    return .solidFill(shapeLayer)
+  }
+
+  private func setupGradientFillLayerHierarchy(
+    for gradientFill: GradientFill)
+    -> FillLayerConfiguration
+  {
+    let pathMask = CAShapeLayer()
+    pathMask.fillColor = .rgb(0, 0, 0)
+    mask = pathMask
+
+    let rgbGradientLayer = GradientRenderLayer()
+    addSublayer(rgbGradientLayer)
+
+    let alphaGradientLayer: GradientRenderLayer?
+    if gradientFill.hasAlphaComponent {
+      alphaGradientLayer = GradientRenderLayer()
+      rgbGradientLayer.mask = alphaGradientLayer
+    } else {
+      alphaGradientLayer = nil
+    }
+
+    return .gradientFill(GradientLayers(
+      gradientColorLayer: rgbGradientLayer,
+      gradientAlphaLayer: alphaGradientLayer,
+      shapeMaskLayer: pathMask))
+  }
+
+  private func setupGradientStrokeLayerHierarchy(
+    for gradientStroke: GradientStroke)
+    -> GradientLayers
+  {
+    let container = BaseAnimationLayer()
+
+    let pathMask = CAShapeLayer()
+    pathMask.fillColor = nil
+    pathMask.strokeColor = .rgb(0, 0, 0)
+    container.mask = pathMask
+
+    let rgbGradientLayer = GradientRenderLayer()
+    container.addSublayer(rgbGradientLayer)
+    addSublayer(container)
+
+    let alphaGradientLayer: GradientRenderLayer?
+    if gradientStroke.hasAlphaComponent {
+      alphaGradientLayer = GradientRenderLayer()
+      rgbGradientLayer.mask = alphaGradientLayer
+    } else {
+      alphaGradientLayer = nil
+    }
+
+    return GradientLayers(
+      gradientColorLayer: rgbGradientLayer,
+      gradientAlphaLayer: alphaGradientLayer,
+      shapeMaskLayer: pathMask)
+  }
+
+  private func setupSolidFillAnimations(
+    shapeLayer: CAShapeLayer,
+    context: LayerAnimationContext)
+    throws
+  {
+    var trimPathMultiplier: PathMultiplier? = nil
+    if let (trim, context) = otherItems.first(Trim.self, context: context) {
+      trimPathMultiplier = try shapeLayer.addAnimations(for: trim, context: context)
+    }
+
+    try shapeLayer.addAnimations(for: shape.item, context: context.for(shape), pathMultiplier: trimPathMultiplier ?? 1)
+
+    if let (fill, context) = otherItems.first(Fill.self, context: context) {
+      try shapeLayer.addAnimations(for: fill, context: context)
+    }
+
+    if let (stroke, context) = otherItems.first(Stroke.self, context: context) {
+      try shapeLayer.addStrokeAnimations(for: stroke, context: context)
+    }
+  }
+
+  private func setupGradientFillAnimations(
+    layers: GradientLayers,
+    context: LayerAnimationContext)
+    throws
+  {
+    try layers.shapeMaskLayer.addAnimations(
+      for: shape.item,
+      context: context.for(shape),
+      pathMultiplier: 1)
+
+    if let (gradientFill, context) = otherItems.first(GradientFill.self, context: context) {
+      try layers.gradientColorLayer.addGradientAnimations(for: gradientFill, type: .rgb, context: context)
+      try layers.gradientAlphaLayer?.addGradientAnimations(for: gradientFill, type: .alpha, context: context)
+    }
+  }
+
+  private func setupGradientStrokeAnimations(
+    layers: GradientLayers,
+    context: LayerAnimationContext)
+    throws
+  {
+    var trimPathMultiplier: PathMultiplier? = nil
+    if let (trim, context) = otherItems.first(Trim.self, context: context) {
+      trimPathMultiplier = try layers.shapeMaskLayer.addAnimations(for: trim, context: context)
+    }
+
+    try layers.shapeMaskLayer.addAnimations(
+      for: shape.item,
+      context: context.for(shape),
+      pathMultiplier: trimPathMultiplier ?? 1)
+
+    if let (gradientStroke, context) = otherItems.first(GradientStroke.self, context: context) {
+      try layers.gradientColorLayer.addGradientAnimations(for: gradientStroke, type: .rgb, context: context)
+      try layers.gradientAlphaLayer?.addGradientAnimations(for: gradientStroke, type: .alpha, context: context)
+
+      try layers.shapeMaskLayer.addStrokeAnimations(for: gradientStroke, context: context)
+    }
+  }
+
+}
+
+// MARK: - [ShapeItem] helpers
+
+extension Array where Element == ShapeItemLayer.Item {
+  /// The first `ShapeItem` in this array of the given type
+  func first<ItemType: ShapeItem>(
+    _: ItemType.Type, context: LayerAnimationContext)
+    -> (item: ItemType, context: LayerAnimationContext)?
+  {
+    for item in self {
+      if let match = item.item as? ItemType {
+        return (match, context.for(item))
+      }
+    }
+
+    return nil
+  }
+
+  /// The first `ShapeItem` in this array of the given type
+  func first<ItemType: ShapeItem>(_: ItemType.Type) -> ItemType? {
+    for item in self {
+      if let match = item.item as? ItemType {
+        return match
+      }
+    }
+
+    return nil
+  }
+}
+
+extension LayerAnimationContext {
+  /// An updated `LayerAnimationContext` with the`AnimationKeypath`
+  /// that refers to this specific `ShapeItem`.
+  func `for`(_ item: ShapeItemLayer.Item) -> LayerAnimationContext {
+    var context = self
+
+    if let group = item.parentGroup {
+      context.currentKeypath.keys.append(group.name)
+    }
+
+    context.currentKeypath.keys.append(item.item.name)
+    return context
+  }
+}