lottie-ios 3.2.3 → 3.4.2

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

@@ -0,0 +1,79 @@
+// Created by Cal Stephens on 1/10/22.
+// Copyright © 2022 Airbnb Inc. All rights reserved.
+
+import QuartzCore
+
+// MARK: - ImageLayer
+
+/// The `CALayer` type responsible for rendering `ImageLayerModel`s
+final class ImageLayer: BaseCompositionLayer {
+
+  // MARK: Lifecycle
+
+  init(
+    imageLayer: ImageLayerModel,
+    context: LayerContext)
+  {
+    self.imageLayer = imageLayer
+    super.init(layerModel: imageLayer)
+    setupImage(context: 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))")
+    }
+
+    imageLayer = typedLayer.imageLayer
+    super.init(layer: typedLayer)
+  }
+
+  // MARK: Internal
+
+  func setupImage(context: LayerContext) {
+    guard
+      let imageAsset = context.animation.assetLibrary?.imageAssets[imageLayer.referenceID],
+      let image = context.imageProvider.imageForAsset(asset: imageAsset)
+    else {
+      self.imageAsset = nil
+      contents = nil
+      return
+    }
+
+    self.imageAsset = imageAsset
+    contents = image
+    setNeedsLayout()
+  }
+
+  // MARK: Private
+
+  private let imageLayer: ImageLayerModel
+  private var imageAsset: ImageAsset?
+
+}
+
+// MARK: CustomLayoutLayer
+
+extension ImageLayer: CustomLayoutLayer {
+  func layout(superlayerBounds: CGRect) {
+    anchorPoint = .zero
+
+    guard let imageAsset = imageAsset else {
+      bounds = superlayerBounds
+      return
+    }
+
+    // Image layers specifically need to use the size of the image itself
+    bounds = CGRect(
+      x: superlayerBounds.origin.x,
+      y: superlayerBounds.origin.y,
+      width: CGFloat(imageAsset.width),
+      height: CGFloat(imageAsset.height))
+  }
+}

package/Sources/Private/CoreAnimation/Layers/LayerModel+makeAnimationLayer.swift

@@ -0,0 +1,64 @@
+// Created by Cal Stephens on 12/20/21.
+// Copyright © 2021 Airbnb Inc. All rights reserved.
+
+import QuartzCore
+
+// MARK: - LayerContext
+
+/// Context available when constructing an `AnimationLayer`
+struct LayerContext {
+  let animation: Animation
+  let imageProvider: AnimationImageProvider
+  let fontProvider: AnimationFontProvider
+  let compatibilityTracker: CompatibilityTracker
+  var layerName: String
+
+  func forLayer(_ layer: LayerModel) -> LayerContext {
+    var context = self
+    context.layerName = layer.name
+    return context
+  }
+}
+
+// MARK: - LayerModel + makeAnimationLayer
+
+extension LayerModel {
+  /// Constructs an `AnimationLayer` / `CALayer` that represents this `LayerModel`
+  func makeAnimationLayer(context: LayerContext) throws -> BaseCompositionLayer? {
+    let context = context.forLayer(self)
+
+    if hidden {
+      return TransformLayer(layerModel: self)
+    }
+
+    switch (type, self) {
+    case (.precomp, let preCompLayerModel as PreCompLayerModel):
+      let preCompLayer = PreCompLayer(preCompLayer: preCompLayerModel)
+      try preCompLayer.setup(context: context)
+      return preCompLayer
+
+    case (.solid, let solidLayerModel as SolidLayerModel):
+      return SolidLayer(solidLayerModel)
+
+    case (.shape, let shapeLayerModel as ShapeLayerModel):
+      return try ShapeLayer(shapeLayer: shapeLayerModel, context: context)
+
+    case (.image, let imageLayerModel as ImageLayerModel):
+      return ImageLayer(imageLayer: imageLayerModel, context: context)
+
+    case (.text, let textLayerModel as TextLayerModel):
+      return try TextLayer(textLayerModel: textLayerModel, context: context)
+
+    case (.null, _):
+      return TransformLayer(layerModel: self)
+
+    default:
+      try context.logCompatibilityIssue("""
+        Unexpected layer type combination ("\(type)" and "\(Swift.type(of: self))")
+        """)
+
+      return nil
+    }
+  }
+
+}

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: MaskCompositionLayer.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/RepeaterLayer.swift

@@ -0,0 +1,85 @@
+// Created by Cal Stephens on 8/1/22.
+// Copyright © 2022 Airbnb Inc. All rights reserved.
+
+import QuartzCore
+
+// MARK: - RepeaterLayer
+
+/// A layer that renders a child layer at some offset using a `Repeater`
+final class RepeaterLayer: BaseAnimationLayer {
+
+  // MARK: Lifecycle
+
+  init(repeater: Repeater, childLayer: CALayer, index: Int) {
+    repeaterTransform = RepeaterTransform(repeater: repeater, index: index)
+    super.init()
+    addSublayer(childLayer)
+  }
+
+  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))")
+    }
+
+    repeaterTransform = typedLayer.repeaterTransform
+    super.init(layer: typedLayer)
+  }
+
+  // MARK: Internal
+
+  override func setupAnimations(context: LayerAnimationContext) throws {
+    try super.setupAnimations(context: context)
+    try addTransformAnimations(for: repeaterTransform, context: context)
+  }
+
+  // MARK: Private
+
+  private let repeaterTransform: RepeaterTransform
+
+}
+
+// MARK: - RepeaterTransform
+
+/// A transform model created from a `Repeater`
+private struct RepeaterTransform {
+
+  // MARK: Lifecycle
+
+  init(repeater: Repeater, index: Int) {
+    anchorPoint = repeater.anchorPoint
+    scale = repeater.scale
+
+    rotation = repeater.rotation.map { rotation in
+      Vector1D(rotation.value * Double(index))
+    }
+
+    position = repeater.position.map { position in
+      Vector3D(
+        x: position.x * Double(index),
+        y: position.y * Double(index),
+        z: position.z * Double(index))
+    }
+  }
+
+  // MARK: Internal
+
+  let anchorPoint: KeyframeGroup<Vector3D>
+  let position: KeyframeGroup<Vector3D>
+  let rotation: KeyframeGroup<Vector1D>
+  let scale: KeyframeGroup<Vector3D>
+
+}
+
+// MARK: TransformModel
+
+extension RepeaterTransform: TransformModel {
+  var _position: KeyframeGroup<Vector3D>? { position }
+  var _positionX: KeyframeGroup<Vector1D>? { nil }
+  var _positionY: KeyframeGroup<Vector1D>? { nil }
+}