lottie-ios 3.2.0 → 3.4.0

package/Tests/Samples/vcTransition2.json

@@ -0,0 +1 @@
+{"assets":[],"layers":[{"ddd":0,"ind":0,"ty":4,"nm":"outLayer","ks":{"o":{"k":100},"r":{"k":0},"p":{"k":[{"i":{"x":0.833,"y":0.833},"o":{"x":0.333,"y":0},"n":"0p833_0p833_0p333_0","t":0,"s":[207,368,0],"e":[527,368,0],"to":[53.3333320617676,0,0],"ti":[-53.3333320617676,0,0]},{"t":13}]},"a":{"k":[0,0,0]},"s":{"k":[{"i":{"x":[0.833,0.833,0.833],"y":[0.833,0.833,0.833]},"o":{"x":[0.167,0.167,0.167],"y":[0.167,0.167,0.167]},"n":["0p833_0p833_0p167_0p167","0p833_0p833_0p167_0p167","0p833_0p833_0p167_0p167"],"t":0,"s":[1175.566,1175.566,100],"e":[4.648,4.648,100]},{"t":13}]}},"ao":0,"shapes":[{"ty":"gr","it":[{"d":1,"ty":"el","s":{"k":[104.875,104.875]},"p":{"k":[0,0]},"nm":"Ellipse Path 1","mn":"ADBE Vector Shape - Ellipse"},{"ty":"fl","fillEnabled":true,"c":{"k":[1,0,0,1]},"o":{"k":100},"nm":"Fill 1","mn":"ADBE Vector Graphic - Fill"},{"ty":"tr","p":{"k":[0,0],"ix":2},"a":{"k":[0,0],"ix":1},"s":{"k":[100,100],"ix":3},"r":{"k":0,"ix":6},"o":{"k":100,"ix":7},"sk":{"k":0,"ix":4},"sa":{"k":0,"ix":5},"nm":"Transform"}],"nm":"Ellipse 1","np":2,"mn":"ADBE Vector Group"}],"ip":0,"op":15,"st":0,"bm":0,"sr":1},{"ddd":0,"ind":1,"ty":4,"nm":"outLayer 10","ks":{"o":{"k":100},"r":{"k":0},"p":{"k":[{"i":{"x":0.833,"y":0.833},"o":{"x":0.333,"y":0},"n":"0p833_0p833_0p333_0","t":4,"s":[207,368,0],"e":[687,368,0],"to":[80,0,0],"ti":[-80,0,0]},{"t":17}]},"a":{"k":[0,0,0]},"s":{"k":[{"i":{"x":[0.833,0.833,0.833],"y":[0.833,0.833,0.833]},"o":{"x":[0.167,0.167,0.167],"y":[0.167,0.167,0.167]},"n":["0p833_0p833_0p167_0p167","0p833_0p833_0p167_0p167","0p833_0p833_0p167_0p167"],"t":4,"s":[1175.566,1175.566,100],"e":[4.648,4.648,100]},{"t":17}]}},"ao":0,"shapes":[{"ty":"gr","it":[{"d":1,"ty":"el","s":{"k":[104.875,104.875]},"p":{"k":[0,0]},"nm":"Ellipse Path 1","mn":"ADBE Vector Shape - Ellipse"},{"ty":"fl","fillEnabled":true,"c":{"k":[0,0.82,0.76,1]},"o":{"k":100},"nm":"Fill 1","mn":"ADBE Vector Graphic - Fill"},{"ty":"tr","p":{"k":[0,0],"ix":2},"a":{"k":[0,0],"ix":1},"s":{"k":[100,100],"ix":3},"r":{"k":0,"ix":6},"o":{"k":100,"ix":7},"sk":{"k":0,"ix":4},"sa":{"k":0,"ix":5},"nm":"Transform"}],"nm":"Ellipse 1","np":2,"mn":"ADBE Vector Group"}],"ip":4,"op":19,"st":4,"bm":0,"sr":1},{"ddd":0,"ind":2,"ty":4,"nm":"inLayer","ks":{"o":{"k":100},"r":{"k":0},"p":{"k":[207,368,0]},"a":{"k":[0,0,0]},"s":{"k":[100,100,100]}},"ao":0,"shapes":[{"ty":"gr","it":[{"ty":"rc","d":1,"s":{"k":[1042.203,1042.203]},"p":{"k":[0,0]},"r":{"k":0},"nm":"Rectangle Path 1","mn":"ADBE Vector Shape - Rect"},{"ty":"fl","fillEnabled":true,"c":{"k":[0,0.01,0.82,1]},"o":{"k":100},"nm":"Fill 1","mn":"ADBE Vector Graphic - Fill"},{"ty":"tr","p":{"k":[0,0],"ix":2},"a":{"k":[0,0],"ix":1},"s":{"k":[100,100],"ix":3},"r":{"k":0,"ix":6},"o":{"k":100,"ix":7},"sk":{"k":0,"ix":4},"sa":{"k":0,"ix":5},"nm":"Transform"}],"nm":"Rectangle 1","np":2,"mn":"ADBE Vector Group"}],"ip":0,"op":77,"st":0,"bm":0,"sr":1}],"v":"4.5.0","ddd":0,"ip":0,"op":22,"fr":24,"w":414,"h":736}

package/Tests/SnapshotConfiguration.swift

@@ -0,0 +1,153 @@
+// Created by Cal Stephens on 12/15/21.
+// Copyright © 2021 Airbnb Inc. All rights reserved.
+
+#if canImport(UIKit)
+import Lottie
+import UIKit
+
+// MARK: - SnapshotConfiguration
+
+/// Snapshot configuration for an individual test case
+struct SnapshotConfiguration {
+  /// The precision that should be used when comparing the
+  /// captured snapshot with the reference image in `Tests/__Snapshots`
+  ///  - Defaults to 1.0 (the snapshot must match exactly).
+  ///  - This can be lowered for snapshots that render somewhat nondeterministically,
+  ///    but should be kept as high as possible (while still permitting the diff to succeed)
+  var precision: Float = 1
+
+  /// Dynamic value providers that should be applied to the animation
+  var customValueProviders: [AnimationKeypath: AnyValueProvider] = [:]
+
+  /// A custom `AnimationImageProvider` to use when rendering this animation
+  var customImageProvider: AnimationImageProvider?
+
+  /// A custom `AnimationFontProvider` to use when rendering this animation
+  var customFontProvider: AnimationFontProvider?
+
+  /// Whether or not this sample should be tested with the automatic engine
+  ///  - Defaults to `false` since this isn't necessary most of the time
+  ///  - Enabling this for a set of animations gives us a regression suite for
+  ///    the code supporting the automatic engine.
+  var testWithAutomaticEngine = false
+}
+
+// MARK: Custom mapping
+
+extension SnapshotConfiguration {
+  /// Custom configurations for individual snapshot tests that
+  /// cannot use the default configuration
+  static let customMapping: [String: SnapshotConfiguration] = [
+    /// These samples appear to render in a slightly non-deterministic way,
+    /// depending on the test environment, so we have to decrease precision a bit.
+    "Issues/issue_1407": .precision(0.9),
+    "Nonanimating/FirstText": .precision(0.99),
+    "Nonanimating/verifyLineHeight": .precision(0.99),
+    "Nonanimating/blend_mode_test": .precision(0.99),
+
+    /// Test cases for the `AnimationKeypath` / `AnyValueProvider` system
+    "Nonanimating/keypathTest": .customValueProviders([
+      AnimationKeypath(keypath: "**.Stroke 1.Color"): ColorValueProvider(.black),
+      AnimationKeypath(keypath: "**.Fill 1.Color"): ColorValueProvider(.red),
+    ]),
+
+    "Switch": .customValueProviders([
+      AnimationKeypath(keypath: "Checkmark Outlines.Group 1.Stroke 1.Color"): ColorValueProvider(.black),
+      AnimationKeypath(keypath: "Checkmark Outlines 2.Group 1.Stroke 1.Color"): ColorValueProvider(.black),
+      AnimationKeypath(keypath: "X Outlines.Group 1.Stroke 1.Color"): ColorValueProvider(.black),
+      AnimationKeypath(keypath: "Switch Outline Outlines.Fill 1.Color"): ColorValueProvider([
+        Keyframe(value: Color.black, time: 0),
+        Keyframe(value: Color(r: 0.76, g: 0.76, b: 0.76, a: 1), time: 75),
+        Keyframe(value: Color.black, time: 150),
+      ]),
+    ]),
+
+    // Test cases for `AnimatedImageProvider`
+    "Nonanimating/_dog": .customImageProvider(HardcodedImageProvider(imageName: "Samples/Images/dog.png")),
+
+    // Test cases for `AnimationFontProvider`
+    "Nonanimating/Text_Glyph": .customFontProvider(HardcodedFontProvider(font: UIFont(name: "Chalkduster", size: 36)!)),
+
+    // Test cases for `RenderingEngineOption.automatic`
+    "9squares_AlBoardman": .useAutomaticRenderingEngine, // Supports the Core Animation engine
+    "LottieFiles/shop": .useAutomaticRenderingEngine, // Throws a compatibility error in `init`
+    "TypeFace/G": .useAutomaticRenderingEngine, // Throws a compatibility error in `display()`
+  ]
+}
+
+// MARK: Helpers
+
+extension SnapshotConfiguration {
+  /// The default configuration to use if no custom mapping is provided
+  static let `default` = SnapshotConfiguration()
+
+  static var useAutomaticRenderingEngine: SnapshotConfiguration {
+    var configuration = SnapshotConfiguration.default
+    configuration.testWithAutomaticEngine = true
+    return configuration
+  }
+
+  /// The `SnapshotConfiguration` to use for the given sample JSON file name
+  static func forSample(named sampleName: String) -> SnapshotConfiguration {
+    if let customConfiguration = customMapping[sampleName] {
+      return customConfiguration
+    } else {
+      return .default
+    }
+  }
+
+  /// A `SnapshotConfiguration` value with `precision` customized to the given value
+  static func precision(_ precision: Float) -> SnapshotConfiguration {
+    var configuration = SnapshotConfiguration.default
+    configuration.precision = precision
+    return configuration
+  }
+
+  /// A `SnapshotConfiguration` value using the given custom value providers
+  static func customValueProviders(
+    _ customValueProviders: [AnimationKeypath: AnyValueProvider])
+    -> SnapshotConfiguration
+  {
+    var configuration = SnapshotConfiguration.default
+    configuration.customValueProviders = customValueProviders
+    return configuration
+  }
+
+  /// A `SnapshotConfiguration` value using the given custom value providers
+  static func customImageProvider(
+    _ customImageProvider: AnimationImageProvider)
+    -> SnapshotConfiguration
+  {
+    var configuration = SnapshotConfiguration.default
+    configuration.customImageProvider = customImageProvider
+    return configuration
+  }
+
+  /// A `SnapshotConfiguration` value using the given custom value providers
+  static func customFontProvider(
+    _ customFontProvider: AnimationFontProvider)
+    -> SnapshotConfiguration
+  {
+    var configuration = SnapshotConfiguration.default
+    configuration.customFontProvider = customFontProvider
+    return configuration
+  }
+
+  /// Whether or not this sample should be included in the snapshot tests for the given configuration
+  func shouldSnapshot(using configuration: LottieConfiguration) -> Bool {
+    switch configuration.renderingEngine {
+    case .automatic:
+      return testWithAutomaticEngine
+    case .specific:
+      return true
+    }
+  }
+}
+
+// MARK: - Color helpers
+
+extension Color {
+  static let black = Color(r: 0, g: 0, b: 0, a: 1)
+  static let red = Color(r: 1, g: 0, b: 0, a: 1)
+}
+#endif

package/Tests/SnapshotTests.swift

@@ -0,0 +1,265 @@
+// Created by Cal Stephens on 12/8/21.
+// Copyright © 2021 Airbnb Inc. All rights reserved.
+
+import SnapshotTesting
+import XCTest
+
+#if canImport(UIKit)
+import UIKit
+#endif
+
+@testable import Lottie
+
+// MARK: - SnapshotTests
+
+class SnapshotTests: XCTestCase {
+
+  // MARK: Internal
+
+  /// Snapshots all of the sample animation JSON files visible to this test target
+  func testMainThreadRenderingEngine() throws {
+    try compareSampleSnapshots(configuration: LottieConfiguration(renderingEngine: .mainThread))
+  }
+
+  /// Snapshots sample animation files using the Core Animation rendering engine
+  func testCoreAnimationRenderingEngine() throws {
+    try compareSampleSnapshots(configuration: LottieConfiguration(renderingEngine: .coreAnimation))
+  }
+
+  /// Snapshots sample animation files using the automatic rendering engine option
+  func testAutomaticRenderingEngine() throws {
+    try compareSampleSnapshots(configuration: LottieConfiguration(renderingEngine: .automatic))
+  }
+
+  /// Validates that all of the snapshots in __Snapshots__ correspond to
+  /// a sample JSON file that is visible to this test target.
+  func testAllSnapshotsHaveCorrespondingSampleFile() {
+    for snapshotURL in Samples.snapshotURLs {
+      // Exclude snapshots of private samples, since those aren't checked in to the repo
+      if snapshotURL.lastPathComponent.contains("Private") {
+        continue
+      }
+
+      // The snapshot files follow the format `testCaseName.animationName-percentage.png`
+      //  - We remove the known prefix and known suffixes to recover the input file name
+      //  - `animationName` can contain dashes, so we can't just split the string at each dash
+      var animationName = snapshotURL.lastPathComponent
+        .replacingOccurrences(of: "testMainThreadRenderingEngine.", with: "")
+        .replacingOccurrences(of: "testCoreAnimationRenderingEngine.", with: "")
+        .replacingOccurrences(of: "testAutomaticRenderingEngine.", with: "")
+
+      for percentage in progressPercentagesToSnapshot {
+        animationName = animationName.replacingOccurrences(
+          of: "-\(Int(percentage * 100)).png",
+          with: "")
+      }
+
+      animationName = animationName.replacingOccurrences(of: "-", with: "/")
+
+      XCTAssert(
+        Samples.sampleAnimationURLs.contains(where: { $0.absoluteString.hasSuffix("\(animationName).json") }),
+        "Snapshot \"\(snapshotURL.lastPathComponent)\" has no corresponding sample animation")
+    }
+  }
+
+  /// Validates that all of the custom snapshot configurations in `SnapshotConfiguration.customMapping`
+  /// reference a sample json file that actually exists
+  func testCustomSnapshotConfigurationsHaveCorrespondingSampleFile() {
+    for (animationName, _) in SnapshotConfiguration.customMapping {
+      let expectedSampleFile = Bundle.module.bundleURL.appendingPathComponent("Samples/\(animationName).json")
+
+      XCTAssert(
+        Samples.sampleAnimationURLs.contains(expectedSampleFile),
+        "Custom configuration for \"\(animationName)\" has no corresponding sample animation")
+    }
+  }
+
+  /// Validates that this test target can access sample json files from `Tests/Samples`
+  /// and snapshot images from `Tests/__Snapshots__`.
+  func testCanAccessSamplesAndSnapshots() {
+    XCTAssert(Samples.sampleAnimationURLs.count > 50)
+    XCTAssert(Samples.snapshotURLs.count > 300)
+  }
+
+  override func setUp() {
+    LottieLogger.shared = .printToConsole
+    TestHelpers.snapshotTestsAreRunning = true
+  }
+
+  override func tearDown() {
+    LottieLogger.shared = LottieLogger()
+    TestHelpers.snapshotTestsAreRunning = false
+  }
+
+  // MARK: Private
+
+  /// `currentProgress` percentages that should be snapshot in `compareSampleSnapshots`
+  private let progressPercentagesToSnapshot = [0, 0.25, 0.5, 0.75, 1.0]
+
+  /// Captures snapshots of `sampleAnimationURLs` and compares them to the snapshot images stored on disk
+  private func compareSampleSnapshots(
+    configuration: LottieConfiguration,
+    testName: String = #function) throws
+  {
+    #if os(iOS)
+    guard UIScreen.main.scale == 2 else {
+      /// Snapshots are captured at a 2x scale, so we can only support
+      /// running tests on a device that has a 2x scale.
+      ///  - In CI we run tests on an iPhone 8 simulator,
+      ///    but any device with a 2x scale works.
+      throw SnapshotError.unsupportedDevice
+    }
+
+    for sampleAnimationName in Samples.sampleAnimationNames {
+      for percent in progressPercentagesToSnapshot {
+        guard
+          let animationView = SnapshotConfiguration.makeAnimationView(
+            for: sampleAnimationName,
+            configuration: configuration)
+        else { continue }
+
+        animationView.currentProgress = CGFloat(percent)
+
+        assertSnapshot(
+          matching: animationView,
+          as: .imageOfPresentationLayer(
+            precision: SnapshotConfiguration.forSample(named: sampleAnimationName).precision),
+          named: "\(sampleAnimationName) (\(Int(percent * 100))%)",
+          testName: testName)
+      }
+    }
+    #else
+    // We only run snapshot tests on iOS, since running snapshot tests
+    // for macOS and tvOS would triple the number of snapshot images
+    // we have to check in to the repo.
+    throw SnapshotError.unsupportedPlatform
+    #endif
+  }
+
+}
+
+// MARK: Animation + snapshotSize
+
+extension Animation {
+  /// The size that this animation should be snapshot at
+  fileprivate var snapshotSize: CGSize {
+    let maxDimension: CGFloat = 500
+
+    // If this is a landscape aspect ratio, we clamp the width
+    if width > height {
+      let newWidth = min(CGFloat(width), maxDimension)
+      let newHeight = newWidth * (CGFloat(height) / CGFloat(width))
+      return CGSize(width: newWidth, height: newHeight)
+    }
+
+    // otherwise, this is either a square or portrait aspect ratio,
+    // in which case we clamp the height
+    else {
+      let newHeight = min(CGFloat(height), maxDimension)
+      let newWidth = newHeight * (CGFloat(width) / CGFloat(height))
+      return CGSize(width: newWidth, height: newHeight)
+    }
+  }
+}
+
+// MARK: - SnapshotError
+
+enum SnapshotError: Error {
+  /// We only run snapshot tests on iOS, since running snapshot tests
+  /// for macOS and tvOS would triple the number of snapshot images
+  /// we have to check in to the repo.
+  case unsupportedPlatform
+
+  /// Snapshots are captured at a 2x scale, so we can only support
+  /// running tests on a device that has a 2x scale.
+  case unsupportedDevice
+}
+
+// MARK: - Samples
+
+/// MARK: - Samples
+
+enum Samples {
+  /// The name of the directory that contains the sample json files
+  static let directoryName = "Samples"
+
+  /// The list of snapshot image files in `Tests/__Snapshots__`
+  static let snapshotURLs = Bundle.module.fileURLs(
+    in: "__Snapshots__",
+    withSuffix: "png")
+
+  /// The list of sample animation files in `Tests/Samples`
+  static let sampleAnimationURLs = Bundle.module.fileURLs(
+    in: Samples.directoryName,
+    withSuffix: "json")
+
+  /// The list of sample animation names in `Tests/Samples`
+  static let sampleAnimationNames = sampleAnimationURLs.lazy
+    .map { sampleAnimationURL -> String in
+      // Each of the sample animation URLs has the format
+      // `.../*.bundle/Samples/{subfolder}/{animationName}.json`.
+      // The sample animation name should include the subfolders
+      // (since that helps uniquely identity the animation JSON file).
+      let pathComponents = sampleAnimationURL.pathComponents
+      let samplesIndex = pathComponents.lastIndex(of: Samples.directoryName)!
+      let subpath = pathComponents[(samplesIndex + 1)...]
+
+      return subpath
+        .joined(separator: "/")
+        .replacingOccurrences(of: ".json", with: "")
+    }
+
+  static func animation(named sampleAnimationName: String) -> Animation? {
+    guard
+      let animation = Animation.named(
+        sampleAnimationName,
+        bundle: .module,
+        subdirectory: Samples.directoryName)
+    else {
+      XCTFail("Could not parse Samples/\(sampleAnimationName).json")
+      return nil
+    }
+
+    return animation
+  }
+}
+
+extension SnapshotConfiguration {
+  /// Creates an `AnimationView` for the sample snapshot with the given name
+  static func makeAnimationView(
+    for sampleAnimationName: String,
+    configuration: LottieConfiguration,
+    logger: LottieLogger = LottieLogger.shared)
+    -> AnimationView?
+  {
+    let snapshotConfiguration = SnapshotConfiguration.forSample(named: sampleAnimationName)
+
+    guard
+      snapshotConfiguration.shouldSnapshot(using: configuration),
+      let animation = Samples.animation(named: sampleAnimationName)
+    else { return nil }
+
+    let animationView = AnimationView(
+      animation: animation,
+      configuration: configuration,
+      logger: logger)
+
+    // Set up the animation view with a valid frame
+    // so the geometry is correct when setting up the `CAAnimation`s
+    animationView.frame.size = animation.snapshotSize
+
+    for (keypath, customValueProvider) in snapshotConfiguration.customValueProviders {
+      animationView.setValueProvider(customValueProvider, keypath: keypath)
+    }
+
+    if let customImageProvider = snapshotConfiguration.customImageProvider {
+      animationView.imageProvider = customImageProvider
+    }
+
+    if let customFontProvider = snapshotConfiguration.customFontProvider {
+      animationView.fontProvider = customFontProvider
+    }
+
+    return animationView
+  }
+}

package/Tests/Utils/Bundle+Module.swift

@@ -0,0 +1,30 @@
+// Created by Cal Stephens on 1/25/22.
+// Copyright © 2022 Airbnb Inc. All rights reserved.
+
+import Foundation
+
+extension Bundle {
+  /// The Bundle representing files in this module
+  static var module: Bundle {
+    Bundle(for: SnapshotTests.self)
+  }
+
+  /// Retrieves URLs for all of the files in the given directory with the given suffix
+  func fileURLs(in directory: String, withSuffix suffix: String) -> [URL] {
+    let enumerator = FileManager.default.enumerator(atPath: Bundle.module.bundlePath)!
+
+    var fileURLs: [URL] = []
+
+    while let fileSubpath = enumerator.nextObject() as? String {
+      if
+        fileSubpath.hasPrefix(directory),
+        fileSubpath.contains(suffix)
+      {
+        let fileURL = Bundle.module.bundleURL.appendingPathComponent(fileSubpath)
+        fileURLs.append(fileURL)
+      }
+    }
+
+    return fileURLs
+  }
+}

package/Tests/Utils/HardcodedFontProvider.swift

@@ -0,0 +1,19 @@
+// Created by Cal Stephens on 2/11/22.
+// Copyright © 2022 Airbnb Inc. All rights reserved.
+
+import Lottie
+import QuartzCore
+#if os(iOS)
+import UIKit
+#endif
+
+// MARK: - HardcodedFontProvider
+
+/// An `AnimationFontProvider` that always returns a specific hardcoded font
+struct HardcodedFontProvider: AnimationFontProvider {
+  let font: CTFont
+
+  func fontFor(family _: String, size _: CGFloat) -> CTFont? {
+    font
+  }
+}

package/Tests/Utils/HardcodedImageProvider.swift

@@ -0,0 +1,23 @@
+// Created by Cal Stephens on 1/19/22.
+// Copyright © 2022 Airbnb Inc. All rights reserved.
+
+import Lottie
+import QuartzCore
+#if os(iOS)
+import UIKit
+#endif
+
+// MARK: - HardcodedImageProvider
+
+/// An `AnimationImageProvider` that always returns a specific hardcoded image of a dog (hi Marley)
+struct HardcodedImageProvider: AnimationImageProvider {
+  let imageName: String
+
+  func imageForAsset(asset _: ImageAsset) -> CGImage? {
+    #if os(iOS)
+    return UIImage(named: imageName, in: .module, compatibleWith: nil)?.cgImage
+    #else
+    return nil
+    #endif
+  }
+}

package/Tests/Utils/Snapshotting+presentationLayer.swift

@@ -0,0 +1,47 @@
+// Created by Cal Stephens on 12/15/21.
+// Copyright © 2021 Airbnb Inc. All rights reserved.
+
+#if os(iOS)
+import SnapshotTesting
+import UIKit
+import XCTest
+
+extension Snapshotting where Value == UIView, Format == UIImage {
+  /// Captures an image of the input `UIView`'s `layer.presentation()`,
+  /// which reflects the current state of any in-flight animations.
+  static func imageOfPresentationLayer(
+    precision: Float = 1,
+    traits: UITraitCollection = .init())
+    -> Snapshotting<UIView, UIImage>
+  {
+    // Use the SnapshotTesting framework's base `SimplySnapshot.image`
+    // implementation for creating and diffing image files
+    SimplySnapshotting.image(precision: precision, scale: traits.displayScale)
+      // Convert the input `UIView` into a `UIImage`
+      // by creating and then rendering its `layer.presentation()`
+      .pullback { (view: UIView) -> UIImage in
+        // Place the view in an on-screen window and then
+        // have Core Animation update the screen synchronously
+        let window = UIWindow()
+        window.bounds = view.bounds
+        window.isHidden = false
+        window.addSubview(view)
+
+        // Calling CATransaction.flush() makes Core Animation synchronously update
+        // the content being displayed on-screen, which gives our view a presentation layer.
+        CATransaction.flush()
+
+        // Now that the view is on-screen, it has a presentation layer:
+        guard let presentationLayer = view.layer.presentation() else {
+          fatalError("Presentation layer does not exist and cannot be snapshot")
+        }
+
+        let image = UIGraphicsImageRenderer(bounds: view.bounds).image { context in
+          presentationLayer.render(in: context.cgContext)
+        }
+
+        return image
+      }
+  }
+}
+#endif

package/Tests/ValueProvidersTests.swift

@@ -0,0 +1,27 @@
+//
+//  ValueProvidersTests.swift
+//  LottieTests
+//
+//  Created by Marcelo Fabri on 5/5/22.
+//
+
+import Lottie
+import XCTest
+
+final class ValueProvidersTests: XCTestCase {
+
+  func testGetValue() throws {
+    let animationView = try XCTUnwrap(SnapshotConfiguration.makeAnimationView(
+      for: "HamburgerArrow",
+      configuration: .init(renderingEngine: .mainThread)))
+
+    let keypath = AnimationKeypath(keypath: "A1.Shape 1.Stroke 1.Color")
+    animationView.setValueProvider(ColorValueProvider(.red), keypath: keypath)
+    let updatedColor = try XCTUnwrap(animationView.getValue(for: keypath, atFrame: 0) as? Color)
+    XCTAssertEqual(updatedColor, .red)
+
+    let originalColor = try XCTUnwrap(animationView.getOriginalValue(for: keypath, atFrame: 0) as? Color)
+    XCTAssertEqual(originalColor, Color(r: 0.4, g: 0.16, b: 0.7, a: 1))
+  }
+
+}

package/lottie-ios.podspec

@@ -1,5 +1,5 @@
 #
-# Be sure to run `pod lib lint lottie-swift.podspec' to ensure this is a
+# Be sure to run `pod lib lint lottie-ios.podspec' to ensure this is a
 # valid spec before submitting.
 #
 # Any lines starting with a # are optional, but their use is encouraged
@@ -8,13 +8,13 @@
 
 Pod::Spec.new do |s|
   s.name             = 'lottie-ios'
-  s.version          = '3.2.0'
-  s.summary          = 'A library to render native animations from bodymovin json. Now in Swift!'
+  s.version          = '3.4.0'
+  s.summary          = 'A library to render native animations from bodymovin json'
 
   s.description = <<-DESC
 Lottie is a mobile library for Android and iOS that parses Adobe After Effects animations exported as json with bodymovin and renders the vector animations natively on mobile and through React Native!
 
-For the first time, designers can create and ship beautiful animations without an engineer painstakingly recreating it be hand. Since the animation is backed by JSON they are extremely small in size but can be large in complexity! Animations can be played, resized, looped, sped up, slowed down, and even interactively scrubbed.
+Lottie enables designers to create and ship beautiful animations without an engineer painstakingly recreating it be hand. Since the animation is backed by JSON they are extremely small in size but can be large in complexity! Animations can be played, resized, looped, sped up, slowed down, and even interactively scrubbed.
   DESC
 
   s.homepage         = 'https://github.com/airbnb/lottie-ios'
@@ -22,16 +22,16 @@ For the first time, designers can create and ship beautiful animations without a
   s.author           = { 'Brandon Withrow' => 'buba447@gmail.com' }
   s.source           = { :git => 'https://github.com/airbnb/lottie-ios.git', :tag => s.version.to_s }
 
-  s.swift_version = '5.0'
-  s.ios.deployment_target = '9.0'
+  s.swift_version = '5.4'
+  s.ios.deployment_target = '11.0'
   s.osx.deployment_target = '10.10'
-  s.tvos.deployment_target = '9.0'
+  s.tvos.deployment_target = '11.0'
 
-  s.source_files = 'lottie-swift/src/**/*'
-  s.ios.source_files = 'lottie-swift/iOS/*.swift'
-  s.ios.exclude_files = 'lottie-swift/src/Public/MacOS/**/*'
-  s.tvos.exclude_files = 'lottie-swift/src/Public/MacOS/**/*'
-  s.osx.exclude_files = 'lottie-swift/src/Public/iOS/**/*'
+  s.source_files = 'Sources/**/*'
+  s.exclude_files = 'Sources/Lottie.swift'
+  s.ios.exclude_files = 'Sources/Public/MacOS/**/*'
+  s.tvos.exclude_files = 'Sources/Public/MacOS/**/*'
+  s.osx.exclude_files = 'Sources/Public/iOS/**/*'
 
   s.ios.frameworks = ['UIKit', 'CoreGraphics', 'QuartzCore']
   s.tvos.frameworks = ['UIKit', 'CoreGraphics', 'QuartzCore']

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lottie-ios",
-  "version": "3.2.0",
+  "version": "3.4.0",
   "description": "Lottie is a mobile library for Android and iOS that parses Adobe After Effects animations exported as json with bodymovin and renders the vector animations natively on mobile and through React Native!",
   "main": "index.js",
   "scripts": {