lottie-ios 3.4.2 → 3.4.4

package/.github/FUNDING.yml

@@ -1,12 +1 @@
-# These are supported funding model platforms
-
-github: [buba447]
-patreon: # Replace with a single Patreon username
 open_collective: lottie
-ko_fi: # Replace with a single Ko-fi username
-tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
-community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
-liberapay: # Replace with a single Liberapay username
-issuehunt: # Replace with a single IssueHunt username
-otechie: # Replace with a single Otechie username
-custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']

package/Lottie.xcodeproj/project.pbxproj

@@ -554,6 +554,7 @@
 		2EAF5B0427A0798700E00531 /* AnimationFontProvider.swift in Sources */ = {isa = PBXBuildFile; fileRef = 2EAF59F227A0798700E00531 /* AnimationFontProvider.swift */; };
 		2EAF5B0527A0798700E00531 /* AnimationFontProvider.swift in Sources */ = {isa = PBXBuildFile; fileRef = 2EAF59F227A0798700E00531 /* AnimationFontProvider.swift */; };
 		2EAF5B0627A0798700E00531 /* AnimationFontProvider.swift in Sources */ = {isa = PBXBuildFile; fileRef = 2EAF59F227A0798700E00531 /* AnimationFontProvider.swift */; };
+		36E57EAC28AF7ADF00B7EFDA /* HardcodedTextProvider.swift in Sources */ = {isa = PBXBuildFile; fileRef = 36E57EAB28AF7ADF00B7EFDA /* HardcodedTextProvider.swift */; };
 		6D0E635F28246BD0007C5DB6 /* Difference in Frameworks */ = {isa = PBXBuildFile; productRef = 6D0E635E28246BD0007C5DB6 /* Difference */; };
 		6D99D6432823790700E5205B /* LegacyGradientFillRenderer.swift in Sources */ = {isa = PBXBuildFile; fileRef = 6D99D6422823790700E5205B /* LegacyGradientFillRenderer.swift */; };
 		6D99D6442823790700E5205B /* LegacyGradientFillRenderer.swift in Sources */ = {isa = PBXBuildFile; fileRef = 6D99D6422823790700E5205B /* LegacyGradientFillRenderer.swift */; };
@@ -783,6 +784,7 @@
 		2EAF59EF27A0798700E00531 /* GradientValueProvider.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = GradientValueProvider.swift; sourceTree = "<group>"; };
 		2EAF59F027A0798700E00531 /* PointValueProvider.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = PointValueProvider.swift; sourceTree = "<group>"; };
 		2EAF59F227A0798700E00531 /* AnimationFontProvider.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = AnimationFontProvider.swift; sourceTree = "<group>"; };
+		36E57EAB28AF7ADF00B7EFDA /* HardcodedTextProvider.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = HardcodedTextProvider.swift; sourceTree = "<group>"; };
 		6D99D6422823790700E5205B /* LegacyGradientFillRenderer.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = LegacyGradientFillRenderer.swift; sourceTree = "<group>"; };
 		6DB3BDB528243FA5002A276D /* ValueProvidersTests.swift */ = {isa = PBXFileReference; indentWidth = 2; lastKnownFileType = sourcecode.swift; path = ValueProvidersTests.swift; sourceTree = "<group>"; tabWidth = 2; };
 		6DB3BDB7282454A6002A276D /* DictionaryInitializable.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = DictionaryInitializable.swift; sourceTree = "<group>"; };
@@ -876,6 +878,7 @@
 				2E8040BF27A07343006E74CB /* Snapshotting+presentationLayer.swift */,
 				2EAF59A627A076BC00E00531 /* Bundle+Module.swift */,
 				2E09FA0527B6CEB600BA84E5 /* HardcodedFontProvider.swift */,
+				36E57EAB28AF7ADF00B7EFDA /* HardcodedTextProvider.swift */,
 			);
 			path = Utils;
 			sourceTree = "<group>";
@@ -1876,6 +1879,7 @@
 				6DEF696E2824A76C007D640F /* BundleTests.swift in Sources */,
 				2EAF59A727A076BC00E00531 /* Bundle+Module.swift in Sources */,
 				2E8044AE27A07347006E74CB /* Snapshotting+presentationLayer.swift in Sources */,
+				36E57EAC28AF7ADF00B7EFDA /* HardcodedTextProvider.swift in Sources */,
 				2E72128527BB32DB0027BC56 /* PerformanceTests.swift in Sources */,
 				6DB3BDC328245AA2002A276D /* ParsingTests.swift in Sources */,
 				6DB3BDB628243FA5002A276D /* ValueProvidersTests.swift in Sources */,
@@ -2670,8 +2674,8 @@
 			isa = XCRemoteSwiftPackageReference;
 			repositoryURL = "https://github.com/pointfreeco/swift-snapshot-testing.git";
 			requirement = {
-				branch = main;
-				kind = branch;
+				kind = revision;
+				revision = 0c2826f26d00ff5ddf2de92cb6b2139b0dd3d1ee;
 			};
 		};
 		6D0E635D28246BD0007C5DB6 /* XCRemoteSwiftPackageReference "Difference" */ = {

package/Lottie.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolved

@@ -0,0 +1,22 @@
+{
+  "pins" : [
+    {
+      "identity" : "difference",
+      "kind" : "remoteSourceControl",
+      "location" : "https://github.com/krzysztofzablocki/Difference",
+      "state" : {
+        "revision" : "02fe1111edc8318c4f8a0da96336fcbcc201f38b",
+        "version" : "1.0.1"
+      }
+    },
+    {
+      "identity" : "swift-snapshot-testing",
+      "kind" : "remoteSourceControl",
+      "location" : "https://github.com/pointfreeco/swift-snapshot-testing.git",
+      "state" : {
+        "revision" : "0c2826f26d00ff5ddf2de92cb6b2139b0dd3d1ee"
+      }
+    }
+  ],
+  "version" : 2
+}

package/Lottie.xcworkspace/xcshareddata/swiftpm/Package.resolved

@@ -23,8 +23,8 @@
         "package": "swift-snapshot-testing",
         "repositoryURL": "https://github.com/pointfreeco/swift-snapshot-testing.git",
         "state": {
-          "branch": "main",
-          "revision": "88f6e2c0afe04221fcfb1601a2ecaad83115a05f",
+          "branch": null,
+          "revision": "0c2826f26d00ff5ddf2de92cb6b2139b0dd3d1ee",
           "version": null
         }
       }

package/Lottie.xcworkspace/xcuserdata/calstephens.xcuserdatad/xcdebugger/Breakpoints_v2.xcbkptlist

@@ -18,5 +18,21 @@
             endingLineNumber = "44">
          </BreakpointContent>
       </BreakpointProxy>
+      <BreakpointProxy
+         BreakpointExtensionID = "Xcode.Breakpoint.FileBreakpoint">
+         <BreakpointContent
+            uuid = "90B95B81-4B28-4BCD-AE7B-59ED8AA81AC1"
+            shouldBeEnabled = "No"
+            ignoreCount = "0"
+            continueAfterRunningActions = "No"
+            filePath = "Sources/Private/MainThread/NodeRenderSystem/NodeProperties/NodeProperty.swift"
+            startingColumnNumber = "9223372036854775807"
+            endingColumnNumber = "9223372036854775807"
+            startingLineNumber = "49"
+            endingLineNumber = "49"
+            landmarkName = "update(frame:)"
+            landmarkType = "7">
+         </BreakpointContent>
+      </BreakpointProxy>
    </Breakpoints>
 </Bucket>

package/Sources/Private/CoreAnimation/Animations/CombinedShapeAnimation.swift

@@ -56,22 +56,25 @@ extension CombinedShapeItem {
   /// Manually combines the given shape keyframes by manually interpolating at each frame
   static func manuallyInterpolating(
     shapes: [KeyframeGroup<BezierPath>],
-    name: String,
-    context: LayerContext)
+    name: String)
     -> CombinedShapeItem
   {
-    let animationTimeRange = Int(context.animation.startFrame)...Int(context.animation.endFrame)
-
     let interpolators = shapes.map { shape in
       KeyframeInterpolator(keyframes: shape.keyframes)
     }
 
-    let interpolatedKeyframes = animationTimeRange.map { frame in
+    let times = shapes.flatMap { $0.keyframes.map { $0.time } }
+
+    let minimumTime = times.min() ?? 0
+    let maximumTime = times.max() ?? 0
+    let animationLocalTimeRange = Int(minimumTime)...Int(maximumTime)
+
+    let interpolatedKeyframes = animationLocalTimeRange.map { localTime in
       Keyframe(
         value: interpolators.compactMap { interpolator in
-          interpolator.value(frame: AnimationFrameTime(frame)) as? BezierPath
+          interpolator.value(frame: AnimationFrameTime(localTime)) as? BezierPath
         },
-        time: AnimationFrameTime(frame))
+        time: AnimationFrameTime(localTime))
     }
 
     return CombinedShapeItem(

package/Sources/Private/CoreAnimation/Animations/GradientAnimations.swift

@@ -36,11 +36,23 @@ extension GradientRenderLayer {
     type: GradientContentType,
     context: LayerAnimationContext) throws
   {
-    // We have to set `colors` to a non-nil value with some valid number of colors
-    // for the color animation below to have any effect
-    colors = .init(
-      repeating: CGColor.rgb(0, 0, 0),
-      count: gradient.numberOfColors)
+    // We have to set `colors` and `locations` to non-nil values
+    // for the animations below to actually take effect
+    locations = []
+
+    // The initial value for `colors` must be an array with the exact same number of colors
+    // as the gradient that will be applied in the `CAAnimation`
+    switch type {
+    case .rgb:
+      colors = .init(
+        repeating: CGColor.rgb(0, 0, 0),
+        count: gradient.numberOfColors)
+
+    case .alpha:
+      colors = .init(
+        repeating: CGColor.rgb(0, 0, 0),
+        count: gradient.colorConfiguration(from: gradient.colors.keyframes[0].value, type: .alpha).count)
+    }
 
     try addAnimation(
       for: .colors,

package/Sources/Private/CoreAnimation/Animations/StrokeAnimation.swift

@@ -55,12 +55,13 @@ extension CAShapeLayer {
     try addOpacityAnimation(for: stroke, context: context)
 
     if let (dashPattern, dashPhase) = stroke.dashPattern?.shapeLayerConfiguration {
-      lineDashPattern = try dashPattern.map {
+      let lineDashPattern = try dashPattern.map {
         try KeyframeGroup(keyframes: $0)
-          .exactlyOneKeyframe(context: context, description: "stroke dashPattern").cgFloatValue as NSNumber
+          .exactlyOneKeyframe(context: context, description: "stroke dashPattern").cgFloatValue
       }
-      if lineDashPattern?.allSatisfy({ $0.floatValue.isZero }) == true {
-        lineDashPattern = nil
+
+      if lineDashPattern.isSupportedLayerDashPattern {
+        self.lineDashPattern = lineDashPattern as [NSNumber]
       }
 
       try addAnimation(

package/Sources/Private/CoreAnimation/CoreAnimationLayer.swift

@@ -17,6 +17,7 @@ final class CoreAnimationLayer: BaseAnimationLayer {
   init(
     animation: Animation,
     imageProvider: AnimationImageProvider,
+    textProvider: AnimationTextProvider,
     fontProvider: AnimationFontProvider,
     compatibilityTrackerMode: CompatibilityTracker.Mode,
     logger: LottieLogger)
@@ -24,6 +25,7 @@ final class CoreAnimationLayer: BaseAnimationLayer {
   {
     self.animation = animation
     self.imageProvider = imageProvider
+    self.textProvider = textProvider
     self.fontProvider = fontProvider
     self.logger = logger
     compatibilityTracker = CompatibilityTracker(mode: compatibilityTrackerMode, logger: logger)
@@ -44,6 +46,7 @@ final class CoreAnimationLayer: BaseAnimationLayer {
     animation = typedLayer.animation
     currentAnimationConfiguration = typedLayer.currentAnimationConfiguration
     imageProvider = typedLayer.imageProvider
+    textProvider = typedLayer.textProvider
     fontProvider = typedLayer.fontProvider
     didSetUpAnimation = typedLayer.didSetUpAnimation
     compatibilityTracker = typedLayer.compatibilityTracker
@@ -92,6 +95,16 @@ final class CoreAnimationLayer: BaseAnimationLayer {
     didSet { reloadImages() }
   }
 
+  /// The `AnimationTextProvider` that `TextLayer`'s use to retrieve texts,
+  /// that they should use to render their text context
+  var textProvider: AnimationTextProvider {
+    didSet {
+      // We need to rebuild the current animation after updating the text provider,
+      // since this is used in `TextLayer.setupAnimations(context:)`
+      rebuildCurrentAnimation()
+    }
+  }
+
   /// The `FontProvider` that `TextLayer`s use to retrieve the `CTFont`
   /// that they should use to render their text content
   var fontProvider: AnimationFontProvider {
@@ -203,6 +216,7 @@ final class CoreAnimationLayer: BaseAnimationLayer {
     LayerContext(
       animation: animation,
       imageProvider: imageProvider,
+      textProvider: textProvider,
       fontProvider: fontProvider,
       compatibilityTracker: compatibilityTracker,
       layerName: "root layer")
@@ -234,6 +248,7 @@ final class CoreAnimationLayer: BaseAnimationLayer {
       compatibilityTracker: compatibilityTracker,
       logger: logger,
       currentKeypath: AnimationKeypath(keys: []),
+      textProvider: textProvider,
       logHierarchyKeypaths: configuration.logHierarchyKeypaths)
 
     // Perform a layout pass if necessary so all of the sublayers
@@ -314,11 +329,18 @@ extension CoreAnimationLayer: RootAnimationLayer {
   }
 
   var isAnimationPlaying: Bool? {
-    switch playbackState {
+    switch pendingAnimationConfiguration?.playbackState {
     case .playing:
-      return animation(forKey: #keyPath(animationProgress)) != nil
-    case nil, .paused:
+      return true
+    case .paused:
       return false
+    case nil:
+      switch playbackState {
+      case .playing:
+        return animation(forKey: #keyPath(animationProgress)) != nil
+      case nil, .paused:
+        return false
+      }
     }
   }
 
@@ -383,15 +405,6 @@ extension CoreAnimationLayer: RootAnimationLayer {
     (sublayers ?? []).filter { $0 is AnimationLayer }
   }
 
-  var textProvider: AnimationTextProvider {
-    get { DictionaryTextProvider([:]) }
-    set {
-      logger.assertionFailure("""
-        The Core Animation rendering engine currently doesn't support `textProvider`s")
-        """)
-    }
-  }
-
   func reloadImages() {
     // When the image provider changes, we have to update all `ImageLayer`s
     // so they can query the most up-to-date image from the new image provider.

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

@@ -41,6 +41,9 @@ struct LayerAnimationContext {
   /// The AnimationKeypath represented by the current layer
   var currentKeypath: AnimationKeypath
 
+  /// The `AnimationTextProvider`
+  var textProvider: AnimationTextProvider
+
   /// Whether or not to log `AnimationKeypath`s for all of the animation's layers
   ///  - Used for `CoreAnimationLayer.logHierarchyKeypaths()`
   var logHierarchyKeypaths: Bool

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

@@ -9,6 +9,7 @@ import QuartzCore
 struct LayerContext {
   let animation: Animation
   let imageProvider: AnimationImageProvider
+  let textProvider: AnimationTextProvider
   let fontProvider: AnimationFontProvider
   let compatibilityTracker: CompatibilityTracker
   var layerName: String

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

@@ -68,12 +68,12 @@ final class PreCompLayer: BaseCompositionLayer {
     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`
+    // animation's global time) via `timeRemapping` or a custom `startTime` / `timeStretch`
     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)
+        return (layerLocalFrame * AnimationFrameTime(preCompLayer.timeStretch)) + AnimationFrameTime(preCompLayer.startTime)
       }
     }
 

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

@@ -157,7 +157,7 @@ final class GroupLayer: BaseAnimationLayer {
         // interpolate the path for each shape at each frame ahead of time so we can combine them
         // into a single set of bezier path keyframes.
         else {
-          combinedShape = .manuallyInterpolating(shapes: allPathKeyframes, name: group.name, context: context)
+          combinedShape = .manuallyInterpolating(shapes: allPathKeyframes, name: group.name)
         }
 
         let sublayer = try ShapeItemLayer(
@@ -253,9 +253,9 @@ extension CALayer {
         pathForChildren.append(group.name)
       }
 
-      let childItems = group.items.map {
-        ShapeItemLayer.Item(item: $0, groupPath: pathForChildren)
-      }
+      let childItems = group.items
+        .filter { !$0.hidden }
+        .map { ShapeItemLayer.Item(item: $0, groupPath: pathForChildren) }
 
       return try GroupLayer(
         group: group,

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

@@ -36,6 +36,21 @@ final class TextLayer: BaseCompositionLayer {
 
   // MARK: Internal
 
+  override func setupAnimations(context: LayerAnimationContext) throws {
+    try super.setupAnimations(context: context)
+    let textAnimationContext = context.addingKeypathComponent(textLayerModel.name)
+
+    let sourceText = try textLayerModel.text.exactlyOneKeyframe(
+      context: textAnimationContext,
+      description: "text layer text")
+
+    renderLayer.text = context.textProvider.textFor(
+      keypathName: textAnimationContext.currentKeypath.fullPath,
+      sourceText: sourceText.text)
+
+    renderLayer.sizeToFit()
+  }
+
   func configureRenderLayer(with context: LayerContext) throws {
     // We can't use `CATextLayer`, because it doesn't support enough features we use.
     // Instead, we use the same `CoreTextRenderLayer` (with a custom `draw` implementation)
@@ -54,7 +69,6 @@ final class TextLayer: BaseCompositionLayer {
         """)
     }
 
-    renderLayer.text = text.text
     renderLayer.font = context.fontProvider.fontFor(family: text.fontFamily, size: CGFloat(text.fontSize))
 
     renderLayer.alignment = text.justification.textAlignment

package/Sources/Private/MainThread/NodeRenderSystem/Extensions/ItemsExtension.swift

@@ -80,7 +80,7 @@ extension Array where Element == ShapeItem {
         nodeTree.paths.append(contentsOf: tree.paths)
         nodeTree.renderContainers.append(node.container)
       } else if item is Repeater {
-        LottieLogger.shared.assertionFailure("""
+        LottieLogger.shared.warn("""
           The Main Thread rendering engine doesn't currently support repeaters.
           To play an animation with repeaters, you can use the Core Animation rendering engine instead.
           """)

package/Sources/Private/MainThread/NodeRenderSystem/Nodes/RenderNodes/GradientStrokeNode.swift

@@ -140,7 +140,7 @@ final class GradientStrokeNode: AnimatorNode, RenderNode {
 
     /// Get dash lengths
     let dashLengths = strokeProperties.dashPattern.value.map { $0.cgFloatValue }
-    if dashLengths.count > 0, !dashLengths.allSatisfy({ $0.isZero }) {
+    if dashLengths.count > 0, dashLengths.isSupportedLayerDashPattern {
       strokeRender.strokeRender.dashPhase = strokeProperties.dashPhase.value.cgFloatValue
       strokeRender.strokeRender.dashLengths = dashLengths
     } else {

package/Sources/Private/MainThread/NodeRenderSystem/Nodes/RenderNodes/StrokeNode.swift

@@ -118,7 +118,7 @@ final class StrokeNode: AnimatorNode, RenderNode {
 
     /// Get dash lengths
     let dashLengths = strokeProperties.dashPattern.value.map { $0.cgFloatValue }
-    if dashLengths.count > 0, !dashLengths.allSatisfy({ $0.isZero }) {
+    if dashLengths.count > 0, dashLengths.isSupportedLayerDashPattern {
       strokeRender.dashPhase = strokeProperties.dashPhase.value.cgFloatValue
       strokeRender.dashLengths = dashLengths
     } else {
@@ -167,3 +167,14 @@ extension Array where Element == DashElement {
     return (dashPatterns, dashPhase)
   }
 }
+
+extension Array where Element == CGFloat {
+  // If all of the items in the dash pattern are zeros, then we shouldn't attempt to render it.
+  // This causes Core Animation to have extremely poor performance for some reason, even though
+  // it doesn't affect the appearance of the animation.
+  //  - We check for `== 0.01` instead of `== 0` because `dashPattern.shapeLayerConfiguration`
+  //    converts all `0` values to `0.01` to work around a different Core Animation rendering issue.
+  var isSupportedLayerDashPattern: Bool {
+    !allSatisfy { $0 == 0.01 }
+  }
+}

package/Sources/Private/Model/Objects/Marker.swift

@@ -15,6 +15,7 @@ final class Marker: Codable, DictionaryInitializable {
   init(dictionary: [String: Any]) throws {
     name = try dictionary.value(for: CodingKeys.name)
     frameTime = try dictionary.value(for: CodingKeys.frameTime)
+    durationFrameTime = try dictionary.value(for: CodingKeys.durationFrameTime)
   }
 
   // MARK: Internal
@@ -22,6 +23,7 @@ final class Marker: Codable, DictionaryInitializable {
   enum CodingKeys: String, CodingKey {
     case name = "cm"
     case frameTime = "tm"
+    case durationFrameTime = "dr"
   }
 
   /// The Marker Name
@@ -30,4 +32,6 @@ final class Marker: Codable, DictionaryInitializable {
   /// The Frame time of the marker
   let frameTime: AnimationFrameTime
 
+  /// The duration of the marker, in frames.
+  let durationFrameTime: AnimationFrameTime
 }

package/Sources/Public/Animation/AnimationPublic.swift

@@ -172,13 +172,14 @@ extension Animation {
   ///
   public static func loadedFrom(
     url: URL,
+    session: URLSession = .shared,
     closure: @escaping Animation.DownloadClosure,
     animationCache: AnimationCacheProvider?)
   {
     if let animationCache = animationCache, let animation = animationCache.animation(forKey: url.absoluteString) {
       closure(animation)
     } else {
-      let task = URLSession.shared.dataTask(with: url) { data, _, error in
+      let task = session.dataTask(with: url) { data, _, error in
         guard error == nil, let jsonData = data else {
           DispatchQueue.main.async {
             closure(nil)
@@ -233,6 +234,21 @@ extension Animation {
     return marker.frameTime
   }
 
+  /// Markers are a way to describe a point in time and a duration by a key name.
+  ///
+  /// Markers are encoded into animation JSON. By using markers a designer can mark
+  /// playback points for a developer to use without having to worry about keeping
+  /// track of animation frames. If the animation file is updated, the developer
+  /// does not need to update playback code.
+  ///
+  /// - Returns: The duration frame time for the marker, or `nil` if no marker found.
+  public func durationFrameTime(forMarker named: String) -> AnimationFrameTime? {
+    guard let marker = markerMap?[named] else {
+      return nil
+    }
+    return marker.durationFrameTime
+  }
+
   /// Converts Frame Time (Seconds * Framerate) into Progress Time
   /// (optionally clamped to between 0 and 1).
   public func progressTime(

package/Sources/Public/Animation/AnimationView.swift

@@ -513,6 +513,32 @@ final public class AnimationView: AnimationViewBase {
     addNewAnimationForContext(context)
   }
 
+  /// Plays the animation from a named marker to the end of the marker's duration.
+  ///
+  /// A marker is a point in time with an associated duration that is encoded into the
+  /// animation data and assigned a name.
+  ///
+  /// NOTE: If marker is not found the play command will exit.
+  ///
+  /// - Parameter marker: The start marker for the animation playback.
+  /// - Parameter loopMode: The loop behavior of the animation. If `nil` the view's `loopMode` property will be used.
+  /// - Parameter completion: An optional completion closure to be called when the animation stops.
+  public func play(
+    marker: String,
+    loopMode: LottieLoopMode? = nil,
+    completion: LottieCompletionBlock? = nil)
+  {
+    guard let from = animation?.markerMap?[marker] else {
+      return
+    }
+
+    play(
+      fromFrame: from.frameTime,
+      toFrame: from.frameTime + from.durationFrameTime,
+      loopMode: loopMode,
+      completion: completion)
+  }
+
   /// Stops the animation and resets the view to its start frame.
   ///
   /// The completion closure will be called with `false`
@@ -713,6 +739,21 @@ final public class AnimationView: AnimationViewBase {
     return animation.frameTime(forMarker: named)
   }
 
+  /// Markers are a way to describe a point in time and a duration by a key name.
+  ///
+  /// Markers are encoded into animation JSON. By using markers a designer can mark
+  /// playback points for a developer to use without having to worry about keeping
+  /// track of animation frames. If the animation file is updated, the developer
+  /// does not need to update playback code.
+  ///
+  /// - Returns: The duration frame time for the marker, or `nil` if no marker found.
+  public func durationFrameTime(forMarker named: String) -> AnimationFrameTime? {
+    guard let animation = animation else {
+      return nil
+    }
+    return animation.durationFrameTime(forMarker: named)
+  }
+
   // MARK: Internal
 
   var animationLayer: RootAnimationLayer? = nil
@@ -996,6 +1037,7 @@ final public class AnimationView: AnimationViewBase {
       let coreAnimationLayer = try CoreAnimationLayer(
         animation: animation,
         imageProvider: imageProvider.cachedImageProvider,
+        textProvider: textProvider,
         fontProvider: fontProvider,
         compatibilityTrackerMode: .track,
         logger: logger)
@@ -1030,6 +1072,7 @@ final public class AnimationView: AnimationViewBase {
       let coreAnimationLayer = try CoreAnimationLayer(
         animation: animation,
         imageProvider: imageProvider.cachedImageProvider,
+        textProvider: textProvider,
         fontProvider: fontProvider,
         compatibilityTrackerMode: .abort,
         logger: logger)

package/Sources/Public/iOS/AnimatedButton.swift

@@ -31,29 +31,9 @@ open class AnimatedButton: AnimatedControl {
     isAccessibilityElement = true
   }
 
-  // MARK: Public
-
-  public override var accessibilityTraits: UIAccessibilityTraits {
-    set { super.accessibilityTraits = newValue }
-    get { super.accessibilityTraits.union(.button) }
-  }
-
-  /// Sets the play range for the given UIControlEvent.
-  public func setPlayRange(fromProgress: AnimationProgressTime, toProgress: AnimationProgressTime, event: UIControl.Event) {
-    rangesForEvents[event.rawValue] = (from: fromProgress, to: toProgress)
-  }
+  // MARK: Open
 
-  /// Sets the play range for the given UIControlEvent.
-  public func setPlayRange(fromMarker fromName: String, toMarker toName: String, event: UIControl.Event) {
-    if
-      let start = animationView.progressTime(forMarker: fromName),
-      let end = animationView.progressTime(forMarker: toName)
-    {
-      rangesForEvents[event.rawValue] = (from: start, to: end)
-    }
-  }
-
-  public override func beginTracking(_ touch: UITouch, with event: UIEvent?) -> Bool {
+  open override func beginTracking(_ touch: UITouch, with event: UIEvent?) -> Bool {
     let _ = super.beginTracking(touch, with: event)
     let touchEvent = UIControl.Event.touchDown
     if let playrange = rangesForEvents[touchEvent.rawValue] {
@@ -62,7 +42,7 @@ open class AnimatedButton: AnimatedControl {
     return true
   }
 
-  public override func endTracking(_ touch: UITouch?, with event: UIEvent?) {
+  open override func endTracking(_ touch: UITouch?, with event: UIEvent?) {
     super.endTracking(touch, with: event)
     let touchEvent: UIControl.Event
     if let touch = touch, bounds.contains(touch.location(in: self)) {
@@ -76,6 +56,28 @@ open class AnimatedButton: AnimatedControl {
     }
   }
 
+  // MARK: Public
+
+  public override var accessibilityTraits: UIAccessibilityTraits {
+    set { super.accessibilityTraits = newValue }
+    get { super.accessibilityTraits.union(.button) }
+  }
+
+  /// Sets the play range for the given UIControlEvent.
+  public func setPlayRange(fromProgress: AnimationProgressTime, toProgress: AnimationProgressTime, event: UIControl.Event) {
+    rangesForEvents[event.rawValue] = (from: fromProgress, to: toProgress)
+  }
+
+  /// Sets the play range for the given UIControlEvent.
+  public func setPlayRange(fromMarker fromName: String, toMarker toName: String, event: UIControl.Event) {
+    if
+      let start = animationView.progressTime(forMarker: fromName),
+      let end = animationView.progressTime(forMarker: toName)
+    {
+      rangesForEvents[event.rawValue] = (from: start, to: end)
+    }
+  }
+
   // MARK: Private
 
   private var rangesForEvents: [UInt : (from: CGFloat, to: CGFloat)] =