lottie-ios 3.2.3 → 3.4.2

package/{lottie-swift/src/Private/LayerContainers/AnimationContainer.swift → Sources/Private/MainThread/LayerContainers/MainThreadAnimationLayer.swift}

@@ -1,5 +1,5 @@
 //
-//  AnimationContainer.swift
+//  MainThreadAnimationLayer.swift
 //  lottie-swift
 //
 //  Created by Brandon Withrow on 1/24/19.
@@ -8,118 +8,40 @@
 import Foundation
 import QuartzCore
 
-/**
- The base animation container.
- 
- This layer holds a single composition container and allows for animation of
- the currentFrame property.
- */
-final class AnimationContainer: CALayer {
-  
-  /// The animatable Current Frame Property
-  @NSManaged var currentFrame: CGFloat
-  
-  var imageProvider: AnimationImageProvider {
-    get {
-      return layerImageProvider.imageProvider
-    }
-    set {
-      layerImageProvider.imageProvider = newValue
-    }
-  }
-  
-  func reloadImages() {
-    layerImageProvider.reloadImages()
-  }
-  
-  var renderScale: CGFloat = 1 {
-    didSet {
-      animationLayers.forEach({ $0.renderScale = renderScale })
-    }
-  }
-  
-  public var respectAnimationFrameRate: Bool = false
-  
-  /// Forces the view to update its drawing.
-  func forceDisplayUpdate() {
-    animationLayers.forEach( { $0.displayWithFrame(frame: currentFrame, forceUpdates: true) })
-  }
-  
-  func logHierarchyKeypaths() {
-    print("Lottie: Logging Animation Keypaths")
-    animationLayers.forEach({ $0.logKeypaths(for: nil) })
-  }
-  
-  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 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 layer(for keypath: AnimationKeypath) -> CALayer? {
-    for layer in animationLayers {
-      if let foundLayer = layer.layer(for: keypath) {
-        return foundLayer
-      }
-    }
-    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: - MainThreadAnimationLayer
 
-  var textProvider: AnimationTextProvider {
-    get { return layerTextProvider.textProvider }
-    set { layerTextProvider.textProvider = newValue }
-  }
-  
-  var fontProvider: AnimationFontProvider {
-    get { return layerFontProvider.fontProvider }
-    set { layerFontProvider.fontProvider = newValue }
-  }
-  
-  var animationLayers: ContiguousArray<CompositionLayer>
-  fileprivate let layerImageProvider: LayerImageProvider
-  fileprivate let layerTextProvider: LayerTextProvider
-  fileprivate let layerFontProvider: LayerFontProvider
-  
-  init(animation: Animation, imageProvider: AnimationImageProvider, textProvider: AnimationTextProvider, fontProvider: AnimationFontProvider) {
-    self.layerImageProvider = LayerImageProvider(imageProvider: imageProvider, assets: animation.assetLibrary?.imageAssets)
-    self.layerTextProvider = LayerTextProvider(textProvider: textProvider)
-    self.layerFontProvider = LayerFontProvider(fontProvider: fontProvider)
-    self.animationLayers = []
+/// 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: Animation,
+    imageProvider: AnimationImageProvider,
+    textProvider: AnimationTextProvider,
+    fontProvider: AnimationFontProvider,
+    logger: LottieLogger)
+  {
+    layerImageProvider = LayerImageProvider(imageProvider: imageProvider, assets: animation.assetLibrary?.imageAssets)
+    layerTextProvider = LayerTextProvider(textProvider: textProvider)
+    layerFontProvider = LayerFontProvider(fontProvider: fontProvider)
+    animationLayers = []
+    self.logger = logger
     super.init()
     bounds = animation.bounds
-    let layers = animation.layers.initializeCompositionLayers(assetLibrary: animation.assetLibrary, layerImageProvider: layerImageProvider, textProvider: textProvider, fontProvider: fontProvider, frameRate: CGFloat(animation.framerate))
-    
+    let layers = animation.layers.initializeCompositionLayers(
+      assetLibrary: animation.assetLibrary,
+      layerImageProvider: layerImageProvider,
+      textProvider: textProvider,
+      fontProvider: fontProvider,
+      frameRate: CGFloat(animation.framerate))
+
     var imageLayers = [ImageCompositionLayer]()
     var textLayers = [TextCompositionLayer]()
-    
+
     var mattedLayer: CompositionLayer? = nil
 
     for layer in layers.reversed() {
@@ -137,14 +59,16 @@ final class AnimationContainer: CALayer {
         mattedLayer = nil
         continue
       }
-      if let matte = layer.matteType,
-        (matte == .add || matte == .invert) {
+      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)
@@ -153,64 +77,200 @@ final class AnimationContainer: CALayer {
     layerFontProvider.reloadTexts()
     setNeedsDisplay()
   }
-  
-  /// For CAAnimation Use
-  public override init(layer: Any) {
-    self.animationLayers = []
-    self.layerImageProvider = LayerImageProvider(imageProvider: BlankImageProvider(), assets: nil)
-    self.layerTextProvider = LayerTextProvider(textProvider: DefaultTextProvider())
-    self.layerFontProvider = LayerFontProvider(fontProvider: DefaultFontProvider())
+
+  /// 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)
-    
-    guard let animationLayer = layer as? AnimationContainer else { return }
-    
-    currentFrame = animationLayer.currentFrame
-    
-  }
-  
-  required init?(coder aDecoder: NSCoder) {
+
+    currentFrame = typedLayer.currentFrame
+  }
+
+  required init?(coder _: NSCoder) {
     fatalError("init(coder:) has not been implemented")
   }
-  
+
+  // MARK: Public
+
+  public var respectAnimationFrameRate = false
+
   // MARK: CALayer Animations
-  
+
   override public class func needsDisplay(forKey key: String) -> Bool {
     if key == "currentFrame" {
       return true
     }
     return super.needsDisplay(forKey: key)
   }
-  
+
   override public func action(forKey event: String) -> CAAction? {
     if event == "currentFrame" {
       let animation = CABasicAnimation(keyPath: event)
       animation.timingFunction = CAMediaTimingFunction(name: CAMediaTimingFunctionName.linear)
-      animation.fromValue = self.presentation()?.currentFrame
+      animation.fromValue = presentation()?.currentFrame
       return animation
     }
     return super.action(forKey: event)
   }
-  
+
   public override func display() {
     guard Thread.isMainThread else { return }
     var newFrame: CGFloat
-    if let animationKeys = self.animationKeys(),
-      !animationKeys.isEmpty {
-      newFrame = self.presentation()?.currentFrame ?? self.currentFrame
+    if
+      let animationKeys = animationKeys(),
+      !animationKeys.isEmpty
+    {
+      newFrame = presentation()?.currentFrame ?? currentFrame
     } else {
       // We ignore the presentation's frame if there's no animation in the layer.
-      newFrame = self.currentFrame
+      newFrame = currentFrame
     }
     if respectAnimationFrameRate {
       newFrame = floor(newFrame)
     }
-    animationLayers.forEach( { $0.displayWithFrame(frame: newFrame, forceUpdates: false) })
+    animationLayers.forEach { $0.displayWithFrame(frame: newFrame, forceUpdates: false) }
   }
-  
-}
 
-fileprivate class BlankImageProvider: AnimationImageProvider {
-  func imageForAsset(asset: ImageAsset) -> CGImage? {
+  // MARK: Internal
+
+  /// The animatable Current Frame Property
+  @NSManaged var currentFrame: CGFloat
+
+  var animationLayers: ContiguousArray<CompositionLayer>
+
+  var primaryAnimationKey: AnimationKey {
+    .managed
+  }
+
+  var isAnimationPlaying: Bool? {
+    nil // this state is managed by `AnimationView`
+  }
+
+  var _animationLayers: [CALayer] {
+    Array(animationLayers)
+  }
+
+  var imageProvider: AnimationImageProvider {
+    get {
+      layerImageProvider.imageProvider
+    }
+    set {
+      layerImageProvider.imageProvider = newValue
+    }
+  }
+
+  var renderScale: CGFloat = 1 {
+    didSet {
+      animationLayers.forEach({ $0.renderScale = renderScale })
+    }
+  }
+
+  var textProvider: AnimationTextProvider {
+    get { layerTextProvider.textProvider }
+    set { layerTextProvider.textProvider = newValue }
+  }
+
+  var fontProvider: AnimationFontProvider {
+    get { layerFontProvider.fontProvider }
+    set { layerFontProvider.fontProvider = newValue }
+  }
+
+  func reloadImages() {
+    layerImageProvider.reloadImages()
+  }
+
+  func removeAnimations() {
+    // no-op, since the primary animation is managed by the `AnimationView`.
+  }
+
+  /// Forces the view to update its drawing.
+  func forceDisplayUpdate() {
+    animationLayers.forEach({ $0.displayWithFrame(frame: currentFrame, forceUpdates: true) })
+  }
+
+  func logHierarchyKeypaths() {
+    logger.info("Lottie: Logging Animation Keypaths")
+    animationLayers.forEach({ $0.logKeypaths(for: nil, logger: self.logger) })
+  }
+
+  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 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 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 class BlankImageProvider: AnimationImageProvider {
+  func imageForAsset(asset _: ImageAsset) -> CGImage? {
+    nil
+  }
 }

package/Sources/Private/MainThread/LayerContainers/Utility/CachedImageProvider.swift

@@ -0,0 +1,47 @@
+// Created by Jianjun Wu on 2022/5/12.
+// Copyright © 2022 Airbnb Inc. All rights reserved.
+
+import CoreGraphics
+import Foundation
+
+// 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
+  ///
+  public init(imageProvider: AnimationImageProvider) {
+    self.imageProvider = imageProvider
+  }
+
+  // MARK: Public
+
+  public func imageForAsset(asset: ImageAsset) -> CGImage? {
+    if let image = imageCache.object(forKey: asset.id as NSString) {
+      return image
+    }
+    if let image = imageProvider.imageForAsset(asset: asset) {
+      imageCache.setObject(image, forKey: asset.id as NSString)
+      return image
+    }
+    return nil
+  }
+
+  // MARK: Internal
+
+  let imageCache: NSCache<NSString, CGImage> = .init()
+  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 {
+    CachedImageProvider(imageProvider: self)
+  }
+}

package/{lottie-swift/src/Private → Sources/Private/MainThread}/LayerContainers/Utility/CompositionLayersInitializer.swift

@@ -5,22 +5,24 @@
 //  Created by Brandon Withrow on 1/25/19.
 //
 
-import Foundation
 import CoreGraphics
+import Foundation
 
 extension Array where Element == LayerModel {
-  
-  func initializeCompositionLayers(assetLibrary: AssetLibrary?,
-                                   layerImageProvider: LayerImageProvider,
-                                   textProvider: AnimationTextProvider,
-                                   fontProvider: AnimationFontProvider,
-                                   frameRate: CGFloat) -> [CompositionLayer] {
+
+  func initializeCompositionLayers(
+    assetLibrary: AssetLibrary?,
+    layerImageProvider: LayerImageProvider,
+    textProvider: AnimationTextProvider,
+    fontProvider: AnimationFontProvider,
+    frameRate: CGFloat) -> [CompositionLayer]
+  {
     var compositionLayers = [CompositionLayer]()
     var layerMap = [Int : CompositionLayer]()
-    
+
     /// Organize the assets into a dictionary of [ID : ImageAsset]
     var childLayers = [LayerModel]()
-    
+
     for layer in self {
       if layer.hidden == true {
         let genericLayer = NullCompositionLayer(layer: layer)
@@ -34,22 +36,29 @@ extension Array where Element == LayerModel {
         let solidContainer = SolidCompositionLayer(solid: solidLayer)
         compositionLayers.append(solidContainer)
         layerMap[layer.index] = solidContainer
-      } else if let precompLayer = layer as? PreCompLayerModel,
+      } else if
+        let precompLayer = layer as? PreCompLayerModel,
         let assetLibrary = assetLibrary,
-        let precompAsset = assetLibrary.precompAssets[precompLayer.referenceID] {
-        let precompContainer = PreCompositionLayer(precomp: precompLayer,
-                                                   asset: precompAsset,
-                                                   layerImageProvider: layerImageProvider,
-                                                   textProvider: textProvider,
-                                                   fontProvider: fontProvider,
-                                                   assetLibrary: assetLibrary,
-                                                   frameRate: frameRate)
+        let precompAsset = assetLibrary.precompAssets[precompLayer.referenceID]
+      {
+        let precompContainer = PreCompositionLayer(
+          precomp: precompLayer,
+          asset: precompAsset,
+          layerImageProvider: layerImageProvider,
+          textProvider: textProvider,
+          fontProvider: fontProvider,
+          assetLibrary: assetLibrary,
+          frameRate: frameRate)
         compositionLayers.append(precompContainer)
         layerMap[layer.index] = precompContainer
-      } else if let imageLayer = layer as? ImageLayerModel,
+      } else if
+        let imageLayer = layer as? ImageLayerModel,
         let assetLibrary = assetLibrary,
-        let imageAsset = assetLibrary.imageAssets[imageLayer.referenceID] {
-        let imageContainer = ImageCompositionLayer(imageLayer: imageLayer, size: CGSize(width: imageAsset.width, height: imageAsset.height))
+        let imageAsset = assetLibrary.imageAssets[imageLayer.referenceID]
+      {
+        let imageContainer = ImageCompositionLayer(
+          imageLayer: imageLayer,
+          size: CGSize(width: imageAsset.width, height: imageAsset.height))
         compositionLayers.append(imageContainer)
         layerMap[layer.index] = imageContainer
       } else if let textLayer = layer as? TextLayerModel {
@@ -65,7 +74,7 @@ extension Array where Element == LayerModel {
         childLayers.append(layer)
       }
     }
-    
+
     /// Now link children with their parents
     for layerModel in childLayers {
       if let parentID = layerModel.parent {
@@ -74,8 +83,8 @@ extension Array where Element == LayerModel {
         childLayer?.transformNode.parentNode = parentLayer?.transformNode
       }
     }
-    
+
     return compositionLayers
   }
-  
+
 }