@octane-xplat/lottie 0.9.0 → 0.10.0

package/platforms/macos/src/vendor/Lottie/Private/MainThread/LayerContainers/CompLayers/TextCompositionLayer.swift

@@ -0,0 +1,247 @@
+//
+//  TextCompositionLayer.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/25/19.
+//
+
+/// Needed for NSMutableParagraphStyle...
+#if os(OSX)
+import AppKit
+#else
+import UIKit
+#endif
+
+extension TextJustification {
+  var textAlignment: NSTextAlignment {
+    switch self {
+    case .left:
+      .left
+    case .right:
+      .right
+    case .center:
+      .center
+    case .justifyLastLineLeft, .justifyLastLineRight, .justifyLastLineCenter, .justifyLastLineFull:
+      .justified
+    }
+  }
+
+  var caTextAlignement: CATextLayerAlignmentMode {
+    switch self {
+    case .left:
+      .left
+    case .right:
+      .right
+    case .center:
+      .center
+    case .justifyLastLineLeft, .justifyLastLineRight, .justifyLastLineCenter, .justifyLastLineFull:
+      .justified
+    }
+  }
+}
+
+// MARK: - TextCompositionLayer
+
+final class TextCompositionLayer: CompositionLayer {
+
+  // MARK: Lifecycle
+
+  init(
+    textLayer: TextLayerModel,
+    textProvider: AnimationKeypathTextProvider,
+    fontProvider: AnimationFontProvider,
+    rootAnimationLayer: MainThreadAnimationLayer?
+  ) {
+    var rootNode: TextAnimatorNode?
+    for animator in textLayer.animators {
+      rootNode = TextAnimatorNode(parentNode: rootNode, textAnimator: animator)
+    }
+    self.rootNode = rootNode
+    textDocument = KeyframeInterpolator(keyframes: textLayer.text.keyframes)
+
+    let transparent = LottieColor(r: 0, g: 0, b: 0, a: 0)
+    let black = LottieColor(r: 0, g: 0, b: 0, a: 1)
+
+    let fillKeyframes = textLayer.text.keyframes.map { keyframe in
+      keyframe.withValue(keyframe.value.fillColorData ?? black)
+    }
+    fillColorNode = NodeProperty(provider: KeyframeInterpolator(keyframes: ContiguousArray(fillKeyframes)))
+
+    let strokeKeyframes = textLayer.text.keyframes.map { keyframe in
+      keyframe.withValue(keyframe.value.strokeColorData ?? transparent)
+    }
+    strokeColorNode = NodeProperty(provider: KeyframeInterpolator(keyframes: ContiguousArray(strokeKeyframes)))
+
+    self.textProvider = textProvider
+    self.fontProvider = fontProvider
+    self.rootAnimationLayer = rootAnimationLayer
+
+    super.init(layer: textLayer, size: .zero)
+    contentsLayer.addSublayer(self.textLayer)
+    self.textLayer.masksToBounds = false
+    self.textLayer.isGeometryFlipped = true
+
+    if let rootNode {
+      childKeypaths.append(rootNode)
+    }
+  }
+
+  required init?(coder _: NSCoder) {
+    fatalError("init(coder:) has not been implemented")
+  }
+
+  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? TextCompositionLayer else {
+      fatalError("init(layer:) Wrong Layer Class")
+    }
+    rootNode = nil
+    textDocument = nil
+
+    fillColorNode = layer.fillColorNode
+    strokeColorNode = layer.strokeColorNode
+
+    textProvider = DefaultTextProvider()
+    fontProvider = DefaultFontProvider()
+
+    super.init(layer: layer)
+  }
+
+  // MARK: Internal
+
+  let rootNode: TextAnimatorNode?
+  let textDocument: KeyframeInterpolator<TextDocument>?
+
+  let fillColorNode: NodeProperty<LottieColor>
+  let strokeColorNode: NodeProperty<LottieColor>
+
+  let textLayer = CoreTextRenderLayer()
+  var textProvider: AnimationKeypathTextProvider
+  var fontProvider: AnimationFontProvider
+  weak var rootAnimationLayer: MainThreadAnimationLayer?
+
+  lazy var fullAnimationKeypath: AnimationKeypath = // Individual layers don't know their full keypaths, so we have to delegate
+    // to the `MainThreadAnimationLayer` to search the layer hierarchy and find
+    // the full keypath (which includes this layer's parent layers)
+    rootAnimationLayer?.keypath(for: self)
+    // If that failed for some reason, just use the last path component (which we do have here)
+    ?? AnimationKeypath(keypath: keypathName)
+
+  override var keypathProperties: [String: AnyNodeProperty] {
+    guard rootNode != nil else {
+      return [
+        PropertyName.color.rawValue: fillColorNode,
+        PropertyName.strokeColor.rawValue: strokeColorNode,
+      ]
+    }
+    var properties = super.keypathProperties
+    properties[PropertyName.color.rawValue] = fillColorNode
+    properties[PropertyName.strokeColor.rawValue] = strokeColorNode
+    return properties
+  }
+
+  override func displayContentsWithFrame(frame: CGFloat, forceUpdates: Bool) {
+    guard let textDocument else { return }
+
+    textLayer.contentsScale = renderScale
+
+    fillColorNode.update(frame: frame)
+    strokeColorNode.update(frame: frame)
+
+    let documentUpdate = textDocument.hasUpdate(frame: frame)
+    let animatorUpdate = rootNode?.updateContents(frame, forceLocalUpdate: forceUpdates) ?? false
+    guard
+      documentUpdate == true ||
+      animatorUpdate == true ||
+      fillColorNode.needsUpdate(frame: frame) ||
+      strokeColorNode.needsUpdate(frame: frame)
+    else { return }
+
+    rootNode?.rebuildOutputs(frame: frame)
+
+    // Get Text Attributes
+    let text = textDocument.value(frame: frame) as! TextDocument
+
+    // Prior to Lottie 4.3.0 the Main Thread rendering engine always just used `LegacyAnimationTextProvider`
+    // and called it with the `keypathName` (only the last path component of the full keypath).
+    // Starting in Lottie 4.3.0 we use `AnimationKeypathTextProvider` instead if implemented.
+    let textString: String =
+      if let keypathTextValue = textProvider.text(for: fullAnimationKeypath, sourceText: text.text) {
+        keypathTextValue
+      } else if let legacyTextProvider = textProvider as? LegacyAnimationTextProvider {
+        legacyTextProvider.textFor(keypathName: keypathName, sourceText: text.text)
+      } else {
+        text.text
+      }
+
+    let isStrokeOverridden =
+      (strokeColorNode.valueProvider as AnyObject) !== (strokeColorNode.originalValueProvider as AnyObject)
+
+    let strokeColor: CGColor? =
+      if let animatorStroke = rootNode?.textOutputNode.strokeColor {
+        animatorStroke
+      } else if isStrokeOverridden {
+        strokeColorNode.value.cgColorValue
+      } else {
+        text.strokeColorData?.cgColorValue
+      }
+
+    let strokeWidth = rootNode?.textOutputNode.strokeWidth ?? CGFloat(text.strokeWidth ?? 0)
+    let tracking = (CGFloat(text.fontSize) * (rootNode?.textOutputNode.tracking ?? CGFloat(text.tracking))) / 1000.0
+    let matrix = rootNode?.textOutputNode.xform ?? CATransform3DIdentity
+    let ctFont = fontProvider.fontFor(family: text.fontFamily, size: CGFloat(text.fontSize))
+    let start = rootNode?.textOutputNode.start.flatMap { Int($0) }
+    let end = rootNode?.textOutputNode.end.flatMap { Int($0) }
+    let selectedRangeOpacity = rootNode?.textOutputNode.selectedRangeOpacity
+    let textRangeUnit = rootNode?.textAnimatorProperties.textRangeUnit
+
+    // Set all of the text layer options
+    textLayer.text = textString
+    textLayer.font = ctFont
+    textLayer.alignment = text.justification.textAlignment
+    textLayer.lineHeight = CGFloat(text.lineHeight)
+    textLayer.tracking = tracking
+
+    // Configure the text animators
+    textLayer.start = start
+    textLayer.end = end
+    textLayer.textRangeUnit = textRangeUnit
+    textLayer.selectedRangeOpacity = selectedRangeOpacity
+
+    // Check for an explicit override. If not overridden, we default to `TextDocument`
+    // to support transparency (avoiding the default black color of the value provider).
+    // `fillColorNode` is non-optional and defaults to black if the color was not overridden.
+    // If the color has been overridden, we use the new color: `fillColorNode.value.cgColorValue`.
+    // Otherwise, we use the default color from the text: `text.fillColorData?.cgColorValue`.
+    //
+    // We cannot remove the cast since `AnyValueProvider` is not a class-bound protocol,
+    // so we must cast to `AnyObject` to perform an identity comparison.
+    let isFillOverridden =
+      (fillColorNode.valueProvider as AnyObject) !== (fillColorNode.originalValueProvider as AnyObject)
+
+    textLayer.fillColor =
+      if let fillColor = rootNode?.textOutputNode.fillColor {
+        fillColor
+      } else if isFillOverridden {
+        fillColorNode.value.cgColorValue
+      } else {
+        text.fillColorData?.cgColorValue
+      }
+
+    textLayer.preferredSize = text.textFrameSize?.sizeValue
+    textLayer.strokeOnTop = text.strokeOverFill ?? false
+    textLayer.strokeWidth = strokeWidth
+    textLayer.strokeColor = strokeColor
+    textLayer.sizeToFit()
+
+    textLayer.opacity = Float(rootNode?.textOutputNode.opacity ?? 1)
+    textLayer.transform = CATransform3DIdentity
+    textLayer.position = text.textFramePosition?.pointValue ?? CGPoint.zero
+    textLayer.transform = matrix
+  }
+
+  override func updateRenderScale() {
+    super.updateRenderScale()
+    textLayer.contentsScale = renderScale
+  }
+}

package/platforms/macos/src/vendor/Lottie/Private/MainThread/LayerContainers/MainThreadAnimationLayer.swift

@@ -0,0 +1,321 @@
+//
+//  MainThreadAnimationLayer.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/24/19.
+//
+
+import QuartzCore
+
+// MARK: - MainThreadAnimationLayer
+
+/// The base `CALayer` for the Main Thread rendering engine
+///
+/// This layer holds a single composition container and allows for animation of
+/// the currentFrame property.
+final class MainThreadAnimationLayer: CALayer, RootAnimationLayer {
+
+  // MARK: Lifecycle
+
+  init(
+    animation: LottieAnimation,
+    imageProvider: AnimationImageProvider,
+    textProvider: AnimationKeypathTextProvider,
+    fontProvider: AnimationFontProvider,
+    maskAnimationToBounds: Bool,
+    logger: LottieLogger
+  ) {
+    layerImageProvider = LayerImageProvider(imageProvider: imageProvider, assets: animation.assetLibrary?.imageAssets)
+    layerTextProvider = LayerTextProvider(textProvider: textProvider)
+    layerFontProvider = LayerFontProvider(fontProvider: fontProvider)
+    animationLayers = []
+    self.logger = logger
+    super.init()
+    masksToBounds = maskAnimationToBounds
+    bounds = animation.bounds
+    let layers = animation.layers.initializeCompositionLayers(
+      assetLibrary: animation.assetLibrary,
+      layerImageProvider: layerImageProvider,
+      layerTextProvider: layerTextProvider,
+      layerFontProvider: layerFontProvider,
+      textProvider: textProvider,
+      fontProvider: fontProvider,
+      frameRate: CGFloat(animation.framerate),
+      rootAnimationLayer: self
+    )
+
+    var imageLayers = [ImageCompositionLayer]()
+    var textLayers = [TextCompositionLayer]()
+
+    var mattedLayer: CompositionLayer? = nil
+
+    for layer in layers.reversed() {
+      layer.bounds = bounds
+      animationLayers.append(layer)
+      if let imageLayer = layer as? ImageCompositionLayer {
+        imageLayers.append(imageLayer)
+      }
+      if let textLayer = layer as? TextCompositionLayer {
+        textLayers.append(textLayer)
+      }
+      if let matte = mattedLayer {
+        /// The previous layer requires this layer to be its matte
+        matte.matteLayer = layer
+        mattedLayer = nil
+        continue
+      }
+      if
+        let matte = layer.matteType,
+        matte == .add || matte == .invert
+      {
+        /// We have a layer that requires a matte.
+        mattedLayer = layer
+      }
+      addSublayer(layer)
+    }
+
+    layerImageProvider.addImageLayers(imageLayers)
+    layerImageProvider.reloadImages()
+    layerTextProvider.addTextLayers(textLayers)
+    layerTextProvider.reloadTexts()
+    layerFontProvider.addTextLayers(textLayers)
+    layerFontProvider.reloadTexts()
+    setNeedsDisplay()
+  }
+
+  /// 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))")
+    }
+
+    animationLayers = []
+    layerImageProvider = LayerImageProvider(imageProvider: BlankImageProvider(), assets: nil)
+    layerTextProvider = LayerTextProvider(textProvider: DefaultTextProvider())
+    layerFontProvider = LayerFontProvider(fontProvider: DefaultFontProvider())
+    logger = typedLayer.logger
+    super.init(layer: layer)
+
+    currentFrame = typedLayer.currentFrame
+  }
+
+  required init?(coder _: NSCoder) {
+    fatalError("init(coder:) has not been implemented")
+  }
+
+  // MARK: Internal
+
+  var respectAnimationFrameRate = false
+
+  /// The animatable Current Frame Property
+  @NSManaged var currentFrame: CGFloat
+
+  /// The parent `LottieAnimationLayer` that manages this layer
+  weak var lottieAnimationLayer: LottieAnimationLayer?
+
+  /// Whether or not to use `forceDisplayUpdate()` when rendering each individual frame.
+  ///  - The main thread rendering engine implements optimizations to decrease the amount
+  ///    of properties that have to be re-rendered on each frame. There are some cases
+  ///    where this can result in bugs / incorrect behavior, so we allow it to be disabled.
+  ///  - Forcing a full render on every frame will decrease performance, and is not recommended
+  ///    except as a workaround to a bug in the main thread rendering engine.
+  var forceDisplayUpdateOnEachFrame = false
+
+  var animationLayers: ContiguousArray<CompositionLayer>
+
+  var primaryAnimationKey: AnimationKey {
+    .managed
+  }
+
+  var isAnimationPlaying: Bool? {
+    nil // this state is managed by `LottieAnimationView`
+  }
+
+  var _animationLayers: [CALayer] {
+    Array(animationLayers)
+  }
+
+  var imageProvider: AnimationImageProvider {
+    get {
+      layerImageProvider.imageProvider
+    }
+    set {
+      layerImageProvider.imageProvider = newValue
+    }
+  }
+
+  var renderScale: CGFloat = 1 {
+    didSet {
+      for animationLayer in animationLayers {
+        animationLayer.renderScale = renderScale
+      }
+    }
+  }
+
+  var textProvider: AnimationKeypathTextProvider {
+    get { layerTextProvider.textProvider }
+    set { layerTextProvider.textProvider = newValue }
+  }
+
+  var fontProvider: AnimationFontProvider {
+    get { layerFontProvider.fontProvider }
+    set { layerFontProvider.fontProvider = newValue }
+  }
+
+  override class func needsDisplay(forKey key: String) -> Bool {
+    if key == "currentFrame" {
+      return true
+    }
+    return super.needsDisplay(forKey: key)
+  }
+
+  override func action(forKey event: String) -> CAAction? {
+    if event == "currentFrame" {
+      let animation = CABasicAnimation(keyPath: event)
+      animation.timingFunction = CAMediaTimingFunction(name: CAMediaTimingFunctionName.linear)
+      animation.fromValue = presentation()?.currentFrame
+      return animation
+    }
+    return super.action(forKey: event)
+  }
+
+  override func display() {
+    guard Thread.isMainThread else { return }
+    var newFrame: CGFloat =
+      if
+        let animationKeys = animationKeys(),
+        !animationKeys.isEmpty
+      {
+        presentation()?.currentFrame ?? currentFrame
+      } else {
+        // We ignore the presentation's frame if there's no animation in the layer.
+        currentFrame
+      }
+    if respectAnimationFrameRate {
+      newFrame = floor(newFrame)
+    }
+    for animationLayer in animationLayers {
+      animationLayer.displayWithFrame(frame: newFrame, forceUpdates: forceDisplayUpdateOnEachFrame)
+    }
+  }
+
+  func reloadImages() {
+    layerImageProvider.reloadImages()
+  }
+
+  func removeAnimations() {
+    // no-op, since the primary animation is managed by the `LottieAnimationView`.
+  }
+
+  /// Forces the view to update its drawing.
+  func forceDisplayUpdate() {
+    for animationLayer in animationLayers {
+      animationLayer.displayWithFrame(frame: currentFrame, forceUpdates: true)
+    }
+  }
+
+  func logHierarchyKeypaths() {
+    logger.info("Lottie: Logging Animation Keypaths")
+
+    for keypath in allHierarchyKeypaths() {
+      logger.info(keypath)
+    }
+  }
+
+  func allHierarchyKeypaths() -> [String] {
+    animationLayers.flatMap { $0.allKeypaths() }
+  }
+
+  func setValueProvider(_ valueProvider: AnyValueProvider, keypath: AnimationKeypath) {
+    for layer in animationLayers {
+      if let foundProperties = layer.nodeProperties(for: keypath) {
+        for property in foundProperties {
+          property.setProvider(provider: valueProvider)
+        }
+        layer.displayWithFrame(frame: presentation()?.currentFrame ?? currentFrame, forceUpdates: true)
+      }
+    }
+  }
+
+  func removeValueProvider(for keypath: AnimationKeypath) {
+    for layer in animationLayers {
+      if let foundProperties = layer.nodeProperties(for: keypath) {
+        for property in foundProperties {
+          property.removeProvider()
+        }
+        layer.displayWithFrame(frame: presentation()?.currentFrame ?? currentFrame, forceUpdates: true)
+      }
+    }
+  }
+
+  func getValue(for keypath: AnimationKeypath, atFrame: CGFloat?) -> Any? {
+    for layer in animationLayers {
+      if
+        let foundProperties = layer.nodeProperties(for: keypath),
+        let first = foundProperties.first
+      {
+        return first.valueProvider.value(frame: atFrame ?? currentFrame)
+      }
+    }
+    return nil
+  }
+
+  func getOriginalValue(for keypath: AnimationKeypath, atFrame: AnimationFrameTime?) -> Any? {
+    for layer in animationLayers {
+      if
+        let foundProperties = layer.nodeProperties(for: keypath),
+        let first = foundProperties.first
+      {
+        return first.originalValueProvider.value(frame: atFrame ?? currentFrame)
+      }
+    }
+    return nil
+  }
+
+  func layer(for keypath: AnimationKeypath) -> CALayer? {
+    for layer in animationLayers {
+      if let foundLayer = layer.layer(for: keypath) {
+        return foundLayer
+      }
+    }
+    return nil
+  }
+
+  func keypath(for layerToFind: CALayer) -> AnimationKeypath? {
+    for layer in animationLayers {
+      if let foundKeypath = layer.keypath(for: layerToFind) {
+        return foundKeypath
+      }
+    }
+    return nil
+  }
+
+  func animatorNodes(for keypath: AnimationKeypath) -> [AnimatorNode]? {
+    var results = [AnimatorNode]()
+    for layer in animationLayers {
+      if let nodes = layer.animatorNodes(for: keypath) {
+        results.append(contentsOf: nodes)
+      }
+    }
+    if results.count == 0 {
+      return nil
+    }
+    return results
+  }
+
+  // MARK: Fileprivate
+
+  fileprivate let layerImageProvider: LayerImageProvider
+  fileprivate let layerTextProvider: LayerTextProvider
+  fileprivate let layerFontProvider: LayerFontProvider
+  fileprivate let logger: LottieLogger
+}
+
+// MARK: - BlankImageProvider
+
+private final class BlankImageProvider: AnimationImageProvider {
+  func imageForAsset(asset _: ImageAsset) -> CGImage? {
+    nil
+  }
+}

package/platforms/macos/src/vendor/Lottie/Private/MainThread/LayerContainers/Utility/CachedImageProvider.swift

@@ -0,0 +1,56 @@
+// Created by Jianjun Wu on 2022/5/12.
+// Copyright © 2022 Airbnb Inc. All rights reserved.
+
+import QuartzCore
+
+// MARK: - CachedImageProvider
+
+private final class CachedImageProvider: AnimationImageProvider {
+
+  // MARK: Lifecycle
+
+  /// Initializes an image provider with an image provider
+  ///
+  /// - Parameter imageProvider: The provider to load image from asset
+  ///
+  init(imageProvider: AnimationImageProvider) {
+    self.imageProvider = imageProvider
+  }
+
+  // MARK: Internal
+
+  func imageForAsset(asset: ImageAsset) -> CGImage? {
+    if let image = imageCache.value(forKey: asset.id) {
+      return image
+    }
+    if let image = imageProvider.imageForAsset(asset: asset) {
+      imageCache.setValue(image, forKey: asset.id)
+      return image
+    }
+    return nil
+  }
+
+  func contentsGravity(for asset: ImageAsset) -> CALayerContentsGravity {
+    imageProvider.contentsGravity(for: asset)
+  }
+
+  // MARK: Private
+
+  /// The underlying storage of this cache.
+  ///  - We use the `LRUCache` library instead of `NSCache`, because `NSCache`
+  ///    clears all cached values when the app is backgrounded instead of
+  ///    only when the app receives a memory warning notification.
+  private var imageCache = LRUCache<String, CGImage>()
+  private let imageProvider: AnimationImageProvider
+
+}
+
+extension AnimationImageProvider {
+  /// Create a cache enabled image provider which will reuse the asset image with the same asset id
+  /// It wraps the current provider as image loader, and uses `NSCache` to cache the images for resue.
+  /// The cache will be reset when the `animation` is reset.
+  var cachedImageProvider: AnimationImageProvider {
+    guard cacheEligible else { return self }
+    return CachedImageProvider(imageProvider: self)
+  }
+}