lottie-ios 4.2.0 → 4.3.0

package/Sources/Public/Animation/LottieAnimationView.swift

@@ -54,7 +54,7 @@ public enum LottieBackgroundBehavior {
 // MARK: - LottieLoopMode
 
 /// Defines animation loop behavior
-public enum LottieLoopMode {
+public enum LottieLoopMode: Hashable {
   /// Animation is played once then stops.
   case playOnce
   /// Animation will loop from beginning to end until stopped.
@@ -87,6 +87,8 @@ extension LottieLoopMode: Equatable {
 
 // MARK: - LottieAnimationView
 
+/// A UIView subclass for rendering Lottie animations.
+///  - Also available as a SwiftUI view (`LottieView`) and a CALayer subclass (`LottieAnimationLayer`)
 @IBDesignable
 open class LottieAnimationView: LottieAnimationViewBase {
 
@@ -98,20 +100,21 @@ open class LottieAnimationView: LottieAnimationViewBase {
   public init(
     animation: LottieAnimation?,
     imageProvider: AnimationImageProvider? = nil,
-    textProvider: AnimationTextProvider = DefaultTextProvider(),
+    textProvider: AnimationKeypathTextProvider = DefaultTextProvider(),
     fontProvider: AnimationFontProvider = DefaultFontProvider(),
     configuration: LottieConfiguration = .shared,
     logger: LottieLogger = .shared)
   {
-    self.animation = animation
-    self.imageProvider = imageProvider ?? BundleImageProvider(bundle: Bundle.main, searchPath: nil)
-    self.textProvider = textProvider
-    self.fontProvider = fontProvider
-    self.configuration = configuration
+    lottieAnimationLayer = LottieAnimationLayer(
+      animation: animation,
+      imageProvider: imageProvider,
+      textProvider: textProvider,
+      fontProvider: fontProvider,
+      configuration: configuration,
+      logger: logger)
     self.logger = logger
     super.init(frame: .zero)
     commonInit()
-    makeAnimationLayer(usingEngine: configuration.renderingEngine)
     if let animation = animation {
       frame = animation.bounds
     }
@@ -121,23 +124,21 @@ open class LottieAnimationView: LottieAnimationViewBase {
   public init(
     dotLottie: DotLottieFile?,
     animationId: String? = nil,
-    textProvider: AnimationTextProvider = DefaultTextProvider(),
+    textProvider: AnimationKeypathTextProvider = DefaultTextProvider(),
     fontProvider: AnimationFontProvider = DefaultFontProvider(),
     configuration: LottieConfiguration = .shared,
     logger: LottieLogger = .shared)
   {
-    let dotLottieAnimation = dotLottie?.animation(for: animationId)
-    animation = dotLottieAnimation?.animation
-    imageProvider = dotLottie?.imageProvider ?? BundleImageProvider(bundle: Bundle.main, searchPath: nil)
-    self.textProvider = textProvider
-    self.fontProvider = fontProvider
-    self.configuration = configuration
+    lottieAnimationLayer = LottieAnimationLayer(
+      dotLottie: dotLottie,
+      animationId: animationId,
+      textProvider: textProvider,
+      fontProvider: fontProvider,
+      configuration: configuration,
+      logger: logger)
     self.logger = logger
     super.init(frame: .zero)
     commonInit()
-    loopMode = dotLottieAnimation?.configuration.loopMode ?? .playOnce
-    animationSpeed = CGFloat(dotLottieAnimation?.configuration.speed ?? 1)
-    makeAnimationLayer(usingEngine: configuration.renderingEngine)
     if let animation = animation {
       frame = animation.bounds
     }
@@ -147,54 +148,82 @@ open class LottieAnimationView: LottieAnimationViewBase {
     configuration: LottieConfiguration = .shared,
     logger: LottieLogger = .shared)
   {
-    animation = nil
-    imageProvider = BundleImageProvider(bundle: Bundle.main, searchPath: nil)
-    textProvider = DefaultTextProvider()
-    fontProvider = DefaultFontProvider()
-    self.configuration = configuration
+    lottieAnimationLayer = LottieAnimationLayer(configuration: configuration, logger: logger)
     self.logger = logger
     super.init(frame: .zero)
     commonInit()
   }
 
   public override init(frame: CGRect) {
-    animation = nil
-    imageProvider = BundleImageProvider(bundle: Bundle.main, searchPath: nil)
-    textProvider = DefaultTextProvider()
-    fontProvider = DefaultFontProvider()
-    configuration = .shared
+    lottieAnimationLayer = LottieAnimationLayer(
+      animation: nil,
+      imageProvider: BundleImageProvider(bundle: Bundle.main, searchPath: nil),
+      textProvider: DefaultTextProvider(),
+      fontProvider: DefaultFontProvider(),
+      configuration: .shared,
+      logger: .shared)
     logger = .shared
     super.init(frame: frame)
     commonInit()
   }
 
   required public init?(coder aDecoder: NSCoder) {
-    imageProvider = BundleImageProvider(bundle: Bundle.main, searchPath: nil)
-    textProvider = DefaultTextProvider()
-    fontProvider = DefaultFontProvider()
-    configuration = .shared
+    lottieAnimationLayer = LottieAnimationLayer(
+      animation: nil,
+      imageProvider: BundleImageProvider(bundle: Bundle.main, searchPath: nil),
+      textProvider: DefaultTextProvider(),
+      fontProvider: DefaultFontProvider(),
+      configuration: .shared,
+      logger: .shared)
     logger = .shared
     super.init(coder: aDecoder)
     commonInit()
   }
 
+  convenience init(
+    animationSource: LottieAnimationSource?,
+    imageProvider: AnimationImageProvider? = nil,
+    textProvider: AnimationKeypathTextProvider = DefaultTextProvider(),
+    fontProvider: AnimationFontProvider = DefaultFontProvider(),
+    configuration: LottieConfiguration = .shared,
+    logger: LottieLogger = .shared)
+  {
+    switch animationSource {
+    case .lottieAnimation(let animation):
+      self.init(
+        animation: animation,
+        imageProvider: imageProvider,
+        textProvider: textProvider,
+        fontProvider: fontProvider,
+        configuration: configuration,
+        logger: logger)
+
+    case .dotLottieFile(let dotLottieFile):
+      self.init(
+        dotLottie: dotLottieFile,
+        textProvider: textProvider,
+        fontProvider: fontProvider,
+        configuration: configuration,
+        logger: logger)
+
+    case nil:
+      self.init(
+        animation: nil,
+        imageProvider: imageProvider,
+        textProvider: textProvider,
+        fontProvider: fontProvider,
+        configuration: configuration,
+        logger: logger)
+    }
+  }
+
   // MARK: Open
 
   /// Plays the animation from its current state to the end.
   ///
   /// - Parameter completion: An optional completion closure to be called when the animation completes playing.
   open func play(completion: LottieCompletionBlock? = nil) {
-    guard let animation = animation else {
-      return
-    }
-
-    /// Build a context for the animation.
-    let context = AnimationContext(
-      playFrom: CGFloat(animation.startFrame),
-      playTo: CGFloat(animation.endFrame),
-      closure: completion)
-    removeCurrentAnimationIfNecessary()
-    addNewAnimationForContext(context)
+    lottieAnimationLayer.play(completion: completion)
   }
 
   /// Plays the animation from a progress (0-1) to a progress (0-1).
@@ -209,20 +238,7 @@ open class LottieAnimationView: LottieAnimationViewBase {
     loopMode: LottieLoopMode? = nil,
     completion: LottieCompletionBlock? = nil)
   {
-    guard let animation = animation else {
-      return
-    }
-
-    removeCurrentAnimationIfNecessary()
-    if let loopMode = loopMode {
-      /// Set the loop mode, if one was supplied
-      self.loopMode = loopMode
-    }
-    let context = AnimationContext(
-      playFrom: animation.frameTime(forProgress: fromProgress ?? currentProgress),
-      playTo: animation.frameTime(forProgress: toProgress),
-      closure: completion)
-    addNewAnimationForContext(context)
+    lottieAnimationLayer.play(fromProgress: fromProgress, toProgress: toProgress, loopMode: loopMode, completion: completion)
   }
 
   /// Plays the animation from a start frame to an end frame in the animation's framerate.
@@ -237,17 +253,7 @@ open class LottieAnimationView: LottieAnimationViewBase {
     loopMode: LottieLoopMode? = nil,
     completion: LottieCompletionBlock? = nil)
   {
-    removeCurrentAnimationIfNecessary()
-    if let loopMode = loopMode {
-      /// Set the loop mode, if one was supplied
-      self.loopMode = loopMode
-    }
-
-    let context = AnimationContext(
-      playFrom: fromFrame ?? currentFrame,
-      playTo: toFrame,
-      closure: completion)
-    addNewAnimationForContext(context)
+    lottieAnimationLayer.play(fromFrame: fromFrame, toFrame: toFrame, loopMode: loopMode, completion: completion)
   }
 
   /// Plays the animation from a named marker to another marker.
@@ -272,29 +278,12 @@ open class LottieAnimationView: LottieAnimationViewBase {
     loopMode: LottieLoopMode? = nil,
     completion: LottieCompletionBlock? = nil)
   {
-    guard let animation = animation, let markers = animation.markerMap, let to = markers[toMarker] else {
-      return
-    }
-
-    removeCurrentAnimationIfNecessary()
-    if let loopMode = loopMode {
-      /// Set the loop mode, if one was supplied
-      self.loopMode = loopMode
-    }
-
-    let fromTime: CGFloat
-    if let fromName = fromMarker, let from = markers[fromName] {
-      fromTime = CGFloat(from.frameTime)
-    } else {
-      fromTime = currentFrame
-    }
-
-    let playTo = playEndMarkerFrame ? CGFloat(to.frameTime) : CGFloat(to.frameTime) - 1
-    let context = AnimationContext(
-      playFrom: fromTime,
-      playTo: playTo,
-      closure: completion)
-    addNewAnimationForContext(context)
+    lottieAnimationLayer.play(
+      fromMarker: fromMarker,
+      toMarker: toMarker,
+      playEndMarkerFrame: playEndMarkerFrame,
+      loopMode: loopMode,
+      completion: completion)
   }
 
   /// Plays the animation from a named marker to the end of the marker's duration.
@@ -312,39 +301,70 @@ open class LottieAnimationView: LottieAnimationViewBase {
     loopMode: LottieLoopMode? = nil,
     completion: LottieCompletionBlock? = nil)
   {
-    guard let from = animation?.markerMap?[marker] else {
-      return
-    }
+    lottieAnimationLayer.play(marker: marker, loopMode: loopMode, completion: completion)
+  }
 
-    play(
-      fromFrame: from.frameTime,
-      toFrame: from.frameTime + from.durationFrameTime,
-      loopMode: loopMode,
-      completion: completion)
+  /// Plays the given markers sequentially in order.
+  ///
+  /// A marker is a point in time with an associated duration that is encoded into the
+  /// animation data and assigned a name. Multiple markers can be played sequentially
+  /// to create programmable animations.
+  ///
+  /// If a marker is not found, it will be skipped.
+  ///
+  /// If a marker doesn't have a duration value, it will play with a duration of 0
+  /// (effectively being skipped).
+  ///
+  /// If another animation is played (by calling any `play` method) while this
+  /// marker sequence is playing, the marker sequence will be cancelled.
+  ///
+  /// - Parameter markers: The list of markers to play sequentially.
+  /// - Parameter completion: An optional completion closure to be called when the animation stops.
+  open func play(
+    markers: [String],
+    completion: LottieCompletionBlock? = nil)
+  {
+    lottieAnimationLayer.play(markers: markers, completion: completion)
   }
 
   /// Stops the animation and resets the view to its start frame.
   ///
   /// The completion closure will be called with `false`
   open func stop() {
-    removeCurrentAnimation()
-    currentFrame = 0
+    lottieAnimationLayer.stop()
   }
 
   /// Pauses the animation in its current state.
   ///
   /// The completion closure will be called with `false`
   open func pause() {
-    removeCurrentAnimation()
+    lottieAnimationLayer.pause()
+  }
+
+  /// Applies the given `LottiePlaybackMode` to this layer.
+  /// - Parameter animationCompletionHandler: A closure that is called after
+  ///   an animation triggered by this method completes. This completion
+  ///   handler is **not called** after setting the playback mode to a
+  ///   mode that doesn't animate (e.g. `progress`, `frame`, `time`, or `pause`).
+  open func play(
+    _ playbackMode: LottiePlaybackMode,
+    animationCompletionHandler: LottieCompletionBlock? = nil)
+  {
+    lottieAnimationLayer.play(playbackMode, animationCompletionHandler: animationCompletionHandler)
   }
 
   // MARK: Public
 
   /// The configuration that this `LottieAnimationView` uses when playing its animation
-  public let configuration: LottieConfiguration
+  public var configuration: LottieConfiguration {
+    get { lottieAnimationLayer.configuration }
+    set { lottieAnimationLayer.configuration = newValue }
+  }
 
   /// Value Providers that have been registered using `setValueProvider(_:keypath:)`
-  public private(set) var valueProviders = [AnimationKeypath: AnyValueProvider]()
+  public var valueProviders: [AnimationKeypath: AnyValueProvider] {
+    lottieAnimationLayer.valueProviders
+  }
 
   /// Describes the behavior of an AnimationView when the app is moved to the background.
   ///
@@ -357,39 +377,16 @@ open class LottieAnimationView: LottieAnimationViewBase {
   /// The default for the Core Animation engine is `continuePlaying`,
   /// since the Core Animation engine does not have any CPU overhead.
   public var backgroundBehavior: LottieBackgroundBehavior {
-    get {
-      let currentBackgroundBehavior = _backgroundBehavior ?? .default(for: currentRenderingEngine ?? .mainThread)
-
-      if
-        currentRenderingEngine == .mainThread,
-        _backgroundBehavior == .continuePlaying
-      {
-        logger.assertionFailure("""
-          `LottieBackgroundBehavior.continuePlaying` should not be used with the Main Thread
-          rendering engine, since this would waste CPU resources on playing an animation
-          that is not visible. Consider using a different background mode, or switching to
-          the Core Animation rendering engine (which does not have any CPU overhead).
-          """)
-      }
-
-      return currentBackgroundBehavior
-    }
-    set {
-      _backgroundBehavior = newValue
-    }
+    get { lottieAnimationLayer.backgroundBehavior }
+    set { lottieAnimationLayer.backgroundBehavior = newValue }
   }
 
   /// Sets the animation backing the animation view. Setting this will clear the
   /// view's contents, completion blocks and current state. The new animation will
   /// be loaded up and set to the beginning of its timeline.
   public var animation: LottieAnimation? {
-    didSet {
-      makeAnimationLayer(usingEngine: configuration.renderingEngine)
-
-      if let animation = animation {
-        animationLoaded?(self, animation)
-      }
-    }
+    get { lottieAnimationLayer.animation }
+    set { lottieAnimationLayer.animation = newValue }
   }
 
   /// A closure that is called when `self.animation` is loaded. When setting this closure,
@@ -432,58 +429,44 @@ open class LottieAnimationView: LottieAnimationViewBase {
   ///
   /// Setting this will cause the animation to reload its image contents.
   public var imageProvider: AnimationImageProvider {
-    didSet {
-      animationLayer?.imageProvider = imageProvider.cachedImageProvider
-      reloadImages()
-    }
+    get { lottieAnimationLayer.imageProvider }
+    set { lottieAnimationLayer.imageProvider = newValue }
   }
 
   /// Sets the text provider for animation view. A text provider provides the
   /// animation with values for text layers
-  public var textProvider: AnimationTextProvider {
-    didSet {
-      animationLayer?.textProvider = textProvider
-    }
+  public var textProvider: AnimationKeypathTextProvider {
+    get { lottieAnimationLayer.textProvider }
+    set { lottieAnimationLayer.textProvider = newValue }
   }
 
   /// Sets the text provider for animation view. A text provider provides the
   /// animation with values for text layers
   public var fontProvider: AnimationFontProvider {
-    didSet {
-      animationLayer?.fontProvider = fontProvider
-    }
+    get { lottieAnimationLayer.fontProvider }
+    set { lottieAnimationLayer.fontProvider = newValue }
   }
 
   /// Whether or not the animation is masked to the bounds. Defaults to true.
-  public var maskAnimationToBounds = true {
-    didSet {
-      animationLayer?.masksToBounds = maskAnimationToBounds
-    }
+  public var maskAnimationToBounds: Bool {
+    get { lottieAnimationLayer.maskAnimationToBounds }
+    set { lottieAnimationLayer.maskAnimationToBounds = newValue }
   }
 
   /// Returns `true` if the animation is currently playing.
   public var isAnimationPlaying: Bool {
-    guard let animationLayer = animationLayer else {
-      return false
-    }
-
-    if let valueFromLayer = animationLayer.isAnimationPlaying {
-      return valueFromLayer
-    } else {
-      return animationLayer.animation(forKey: activeAnimationName) != nil
-    }
+    lottieAnimationLayer.isAnimationPlaying
   }
 
   /// Returns `true` if the animation will start playing when this view is added to a window.
   public var isAnimationQueued: Bool {
-    animationContext != nil && waitingToPlayAnimation
+    lottieAnimationLayer.hasAnimationContext && waitingToPlayAnimation
   }
 
   /// Sets the loop behavior for `play` calls. Defaults to `playOnce`
-  public var loopMode: LottieLoopMode = .playOnce {
-    didSet {
-      updateInFlightAnimation()
-    }
+  public var loopMode: LottieLoopMode {
+    get { lottieAnimationLayer.loopMode }
+    set { lottieAnimationLayer.loopMode = newValue }
   }
 
   /// When `true` the animation view will rasterize its contents when not animating.
@@ -492,10 +475,9 @@ open class LottieAnimationView: LottieAnimationViewBase {
   /// Note: this will not produce crisp results at resolutions above the animations natural resolution.
   ///
   /// Defaults to `false`
-  public var shouldRasterizeWhenIdle = false {
-    didSet {
-      updateRasterizationState()
-    }
+  public var shouldRasterizeWhenIdle: Bool {
+    get { lottieAnimationLayer.shouldRasterizeWhenIdle }
+    set { lottieAnimationLayer.shouldRasterizeWhenIdle = newValue }
   }
 
   /// Sets the current animation time with a Progress Time
@@ -503,20 +485,8 @@ open class LottieAnimationView: LottieAnimationViewBase {
   /// Note: Setting this will stop the current animation, if any.
   /// Note 2: If `animation` is nil, setting this will fallback to 0
   public var currentProgress: AnimationProgressTime {
-    set {
-      if let animation = animation {
-        currentFrame = animation.frameTime(forProgress: newValue)
-      } else {
-        currentFrame = 0
-      }
-    }
-    get {
-      if let animation = animation {
-        return animation.progressTime(forFrame: currentFrame)
-      } else {
-        return 0
-      }
-    }
+    get { lottieAnimationLayer.currentProgress }
+    set { lottieAnimationLayer.currentProgress = newValue }
   }
 
   /// Sets the current animation time with a time in seconds.
@@ -524,53 +494,32 @@ open class LottieAnimationView: LottieAnimationViewBase {
   /// Note: Setting this will stop the current animation, if any.
   /// Note 2: If `animation` is nil, setting this will fallback to 0
   public var currentTime: TimeInterval {
-    set {
-      if let animation = animation {
-        currentFrame = animation.frameTime(forTime: newValue)
-      } else {
-        currentFrame = 0
-      }
-    }
-    get {
-      if let animation = animation {
-        return animation.time(forFrame: currentFrame)
-      } else {
-        return 0
-      }
-    }
+    get { lottieAnimationLayer.currentTime }
+    set { lottieAnimationLayer.currentTime = newValue }
   }
 
   /// Sets the current animation time with a frame in the animations framerate.
   ///
   /// Note: Setting this will stop the current animation, if any.
   public var currentFrame: AnimationFrameTime {
-    set {
-      removeCurrentAnimationIfNecessary()
-      updateAnimationFrame(newValue)
-    }
-    get {
-      animationLayer?.currentFrame ?? 0
-    }
+    get { lottieAnimationLayer.currentFrame }
+    set { lottieAnimationLayer.currentFrame = newValue }
   }
 
   /// Returns the current animation frame while an animation is playing.
   public var realtimeAnimationFrame: AnimationFrameTime {
-    isAnimationPlaying ? animationLayer?.presentation()?.currentFrame ?? currentFrame : currentFrame
+    lottieAnimationLayer.realtimeAnimationFrame
   }
 
   /// Returns the current animation frame while an animation is playing.
   public var realtimeAnimationProgress: AnimationProgressTime {
-    if let animation = animation {
-      return animation.progressTime(forFrame: realtimeAnimationFrame)
-    }
-    return 0
+    lottieAnimationLayer.realtimeAnimationProgress
   }
 
   /// Sets the speed of the animation playback. Defaults to 1
-  public var animationSpeed: CGFloat = 1 {
-    didSet {
-      updateInFlightAnimation()
-    }
+  public var animationSpeed: CGFloat {
+    get { lottieAnimationLayer.animationSpeed }
+    set { lottieAnimationLayer.animationSpeed = newValue }
   }
 
   /// When `true` the animation will play back at the framerate encoded in the
@@ -578,10 +527,9 @@ open class LottieAnimationView: LottieAnimationViewBase {
   /// of the device.
   ///
   /// Defaults to false
-  public var respectAnimationFrameRate = false {
-    didSet {
-      animationLayer?.respectAnimationFrameRate = respectAnimationFrameRate
-    }
+  public var respectAnimationFrameRate: Bool {
+    get { lottieAnimationLayer.respectAnimationFrameRate }
+    set { lottieAnimationLayer.respectAnimationFrameRate = newValue }
   }
 
   /// Controls the cropping of an Animation. Setting this property will crop the animation
@@ -589,7 +537,7 @@ open class LottieAnimationView: LottieAnimationViewBase {
   /// in the animation's coordinate space.
   ///
   /// Animatable.
-  public var viewportFrame: CGRect? = nil {
+  public var viewportFrame: CGRect? {
     didSet {
       // This is really ugly, but is needed to trigger a layout pass within an animation block.
       // Typically this happens automatically, when layout objects are UIView based.
@@ -607,7 +555,7 @@ open class LottieAnimationView: LottieAnimationViewBase {
   }
 
   override public var intrinsicContentSize: CGSize {
-    if let animation = animation {
+    if let animation = lottieAnimationLayer.animation {
       return animation.bounds.size
     }
     return .zero
@@ -617,21 +565,25 @@ open class LottieAnimationView: LottieAnimationViewBase {
   ///  - This will only be `nil` in cases where the configuration is `automatic`
   ///    but a `RootAnimationLayer` hasn't been constructed yet
   public var currentRenderingEngine: RenderingEngine? {
-    switch configuration.renderingEngine {
-    case .specific(let engine):
-      return engine
+    lottieAnimationLayer.currentRenderingEngine
+  }
 
-    case .automatic:
-      guard let animationLayer = animationLayer else {
-        return nil
-      }
+  /// The current `LottiePlaybackMode` that is being used
+  public var currentPlaybackMode: LottiePlaybackMode? {
+    lottieAnimationLayer.currentPlaybackMode
+  }
 
-      if animationLayer is CoreAnimationLayer {
-        return .coreAnimation
-      } else {
-        return .mainThread
-      }
-    }
+  /// Whether or not the Main Thread rendering engine should 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.
+  ///  - Has no effect when using the Core Animation rendering engine.
+  public var mainThreadRenderingEngineShouldForceDisplayUpdateOnEachFrame: Bool {
+    get { lottieAnimationLayer.mainThreadRenderingEngineShouldForceDisplayUpdateOnEachFrame }
+    set { lottieAnimationLayer.mainThreadRenderingEngineShouldForceDisplayUpdateOnEachFrame = newValue }
   }
 
   /// Sets the lottie file backing the animation view. Setting this will clear the
@@ -647,26 +599,33 @@ open class LottieAnimationView: LottieAnimationViewBase {
     _ animationId: String? = nil,
     from dotLottieFile: DotLottieFile)
   {
-    guard let dotLottieAnimation = dotLottieFile.animation(for: animationId) else { return }
-
-    loopMode = dotLottieAnimation.configuration.loopMode
-    animationSpeed = CGFloat(dotLottieAnimation.configuration.speed)
-
-    if let imageProvider = dotLottieAnimation.configuration.imageProvider {
-      self.imageProvider = imageProvider
-    }
+    lottieAnimationLayer.loadAnimation(animationId, from: dotLottieFile)
+  }
 
-    animation = dotLottieAnimation.animation
+  /// Sets the lottie file backing the animation view. Setting this will clear the
+  /// view's contents, completion blocks and current state. The new animation will
+  /// be loaded up and set to the beginning of its timeline.
+  /// The loopMode, animationSpeed and imageProvider will be set according
+  /// to lottie file settings
+  /// - Parameters:
+  ///   - atIndex: Internal animation index to play. Optional
+  ///   Defaults to play first animation in file.
+  ///   - dotLottieFile: Lottie file to play
+  public func loadAnimation(
+    atIndex index: Int,
+    from dotLottieFile: DotLottieFile)
+  {
+    lottieAnimationLayer.loadAnimation(atIndex: index, from: dotLottieFile)
   }
 
   /// Reloads the images supplied to the animation from the `imageProvider`
   public func reloadImages() {
-    animationLayer?.reloadImages()
+    lottieAnimationLayer.reloadImages()
   }
 
   /// Forces the LottieAnimationView to redraw its contents.
   public func forceDisplayUpdate() {
-    animationLayer?.forceDisplayUpdate()
+    lottieAnimationLayer.forceDisplayUpdate()
   }
 
   /// Sets a ValueProvider for the specified keypath. The value provider will be set
@@ -692,10 +651,7 @@ open class LottieAnimationView: LottieAnimationViewBase {
   /// animationView.setValueProvider(redValueProvider, keypath: fillKeypath)
   /// ```
   public func setValueProvider(_ valueProvider: AnyValueProvider, keypath: AnimationKeypath) {
-    guard let animationLayer = animationLayer else { return }
-
-    valueProviders[keypath] = valueProvider
-    animationLayer.setValueProvider(valueProvider, keypath: keypath)
+    lottieAnimationLayer.setValueProvider(valueProvider, keypath: keypath)
   }
 
   /// Reads the value of a property specified by the Keypath.
@@ -704,7 +660,7 @@ open class LottieAnimationView: LottieAnimationViewBase {
   /// - Parameter for: The keypath used to search for the property.
   /// - Parameter atFrame: The Frame Time of the value to query. If nil then the current frame is used.
   public func getValue(for keypath: AnimationKeypath, atFrame: AnimationFrameTime?) -> Any? {
-    animationLayer?.getValue(for: keypath, atFrame: atFrame)
+    lottieAnimationLayer.getValue(for: keypath, atFrame: atFrame)
   }
 
   /// Reads the original value of a property specified by the Keypath.
@@ -714,19 +670,19 @@ open class LottieAnimationView: LottieAnimationViewBase {
   /// - Parameter for: The keypath used to search for the property.
   /// - Parameter atFrame: The Frame Time of the value to query. If nil then the current frame is used.
   public func getOriginalValue(for keypath: AnimationKeypath, atFrame: AnimationFrameTime?) -> Any? {
-    animationLayer?.getOriginalValue(for: keypath, atFrame: atFrame)
+    lottieAnimationLayer.getOriginalValue(for: keypath, atFrame: atFrame)
   }
 
   /// Logs all child keypaths.
   /// Logs the result of `allHierarchyKeypaths()` to the `LottieLogger`.
   public func logHierarchyKeypaths() {
-    animationLayer?.logHierarchyKeypaths()
+    lottieAnimationLayer.logHierarchyKeypaths()
   }
 
   /// Computes and returns a list of all child keypaths in the current animation.
   /// The returned list is the same as the log output of `logHierarchyKeypaths()`
   public func allHierarchyKeypaths() -> [String] {
-    animationLayer?.allHierarchyKeypaths() ?? []
+    lottieAnimationLayer.allHierarchyKeypaths()
   }
 
   /// Searches for the nearest child layer to the first Keypath and adds the subview
@@ -751,12 +707,12 @@ open class LottieAnimationView: LottieAnimationViewBase {
   /// animationView.addSubview(subview, forLayerAt: layerKeypath)
   /// ```
   public func addSubview(_ subview: AnimationSubview, forLayerAt keypath: AnimationKeypath) {
-    guard let sublayer = animationLayer?.layer(for: keypath) else {
+    guard let sublayer = lottieAnimationLayer.rootAnimationLayer?.layer(for: keypath) else {
       return
     }
     setNeedsLayout()
     layoutIfNeeded()
-    forceDisplayUpdate()
+    lottieAnimationLayer.forceDisplayUpdate()
     addSubview(subview)
     if let subViewLayer = subview.viewLayer {
       sublayer.addSublayer(subViewLayer)
@@ -771,17 +727,10 @@ open class LottieAnimationView: LottieAnimationViewBase {
   /// - Parameter rect: The CGRect to convert.
   /// - Parameter toLayerAt: The keypath used to find the layer.
   public func convert(_ rect: CGRect, toLayerAt keypath: AnimationKeypath?) -> CGRect? {
-    guard let animationLayer = animationLayer else { return nil }
-    guard let keypath = keypath else {
-      return viewLayer?.convert(rect, to: animationLayer)
-    }
-    guard let sublayer = animationLayer.layer(for: keypath) else {
-      return nil
-    }
+    let convertedRect = lottieAnimationLayer.convert(rect, toLayerAt: keypath)
     setNeedsLayout()
     layoutIfNeeded()
-    forceDisplayUpdate()
-    return animationLayer.convert(rect, to: sublayer)
+    return convertedRect
   }
 
   /// Converts a CGPoint from the LottieAnimationView's coordinate space into the
@@ -792,17 +741,10 @@ open class LottieAnimationView: LottieAnimationViewBase {
   /// - Parameter point: The CGPoint to convert.
   /// - Parameter toLayerAt: The keypath used to find the layer.
   public func convert(_ point: CGPoint, toLayerAt keypath: AnimationKeypath?) -> CGPoint? {
-    guard let animationLayer = animationLayer else { return nil }
-    guard let keypath = keypath else {
-      return viewLayer?.convert(point, to: animationLayer)
-    }
-    guard let sublayer = animationLayer.layer(for: keypath) else {
-      return nil
-    }
+    let convertedRect = lottieAnimationLayer.convert(point, toLayerAt: keypath)
     setNeedsLayout()
     layoutIfNeeded()
-    forceDisplayUpdate()
-    return animationLayer.convert(point, to: sublayer)
+    return convertedRect
   }
 
   /// Sets the enabled state of all animator nodes found with the keypath search.
@@ -811,14 +753,7 @@ open class LottieAnimationView: LottieAnimationViewBase {
   /// - Parameter isEnabled: When true the animator nodes affect the rendering tree. When false the node is removed from the tree.
   /// - Parameter keypath: The keypath used to find the node(s).
   public func setNodeIsEnabled(isEnabled: Bool, keypath: AnimationKeypath) {
-    guard let animationLayer = animationLayer else { return }
-    let nodes = animationLayer.animatorNodes(for: keypath)
-    if let nodes = nodes {
-      for node in nodes {
-        node.isEnabled = isEnabled
-      }
-      forceDisplayUpdate()
-    }
+    lottieAnimationLayer.setNodeIsEnabled(isEnabled: isEnabled, keypath: keypath)
   }
 
   /// Markers are a way to describe a point in time by a key name.
@@ -830,10 +765,7 @@ open class LottieAnimationView: LottieAnimationViewBase {
   ///
   /// Returns the Progress Time for the marker named. Returns nil if no marker found.
   public func progressTime(forMarker named: String) -> AnimationProgressTime? {
-    guard let animation = animation else {
-      return nil
-    }
-    return animation.progressTime(forMarker: named)
+    lottieAnimationLayer.progressTime(forMarker: named)
   }
 
   /// Markers are a way to describe a point in time by a key name.
@@ -845,10 +777,7 @@ open class LottieAnimationView: LottieAnimationViewBase {
   ///
   /// Returns the Frame Time for the marker named. Returns nil if no marker found.
   public func frameTime(forMarker named: String) -> AnimationFrameTime? {
-    guard let animation = animation else {
-      return nil
-    }
-    return animation.frameTime(forMarker: named)
+    lottieAnimationLayer.frameTime(forMarker: named)
   }
 
   /// Markers are a way to describe a point in time and a duration by a key name.
@@ -860,32 +789,51 @@ open class LottieAnimationView: LottieAnimationViewBase {
   ///
   /// - 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)
+    lottieAnimationLayer.durationFrameTime(forMarker: named)
   }
 
   // MARK: Internal
 
-  var animationLayer: RootAnimationLayer? = nil
+  var animationLayer: RootAnimationLayer? {
+    lottieAnimationLayer.rootAnimationLayer
+  }
 
   /// Set animation name from Interface Builder
   @IBInspectable var animationName: String? {
     didSet {
-      self.animation = animationName.flatMap {
-        LottieAnimation.named($0, animationCache: nil)
+      self.lottieAnimationLayer.animation = animationName.flatMap { LottieAnimation.named($0, animationCache: nil)
       }
     }
   }
 
+  override func commonInit() {
+    super.commonInit()
+    lottieAnimationLayer.screenScale = screenScale
+    viewLayer?.addSublayer(lottieAnimationLayer)
+
+    lottieAnimationLayer.animationLoaded = { [weak self] _, animation in
+      guard let self = self else { return }
+      self.animationLoaded?(self, animation)
+      self.invalidateIntrinsicContentSize()
+      self.setNeedsLayout()
+    }
+
+    lottieAnimationLayer.animationLayerDidLoad = { [weak self] _, _ in
+      guard let self = self else { return }
+      self.invalidateIntrinsicContentSize()
+      self.setNeedsLayout()
+    }
+  }
+
   override func layoutAnimation() {
-    guard let animation = animation, let animationLayer = animationLayer else { return }
+    guard let animation = lottieAnimationLayer.animation, let animationLayer = lottieAnimationLayer.animationLayer else { return }
+
     var position = animation.bounds.center
     let xform: CATransform3D
     var shouldForceUpdates = false
 
     if let viewportFrame = viewportFrame {
+      setNeedsLayout()
       shouldForceUpdates = contentMode == .redraw
 
       let compAspect = viewportFrame.size.width / viewportFrame.size.height
@@ -904,7 +852,7 @@ open class LottieAnimationView: LottieAnimationViewBase {
         xform = CATransform3DMakeScale(
           bounds.size.width / animation.size.width,
           bounds.size.height / animation.size.height,
-          1);
+          1)
       case .scaleAspectFit:
         position = bounds.center
         let compAspect = animation.size.width / animation.size.height
@@ -955,7 +903,7 @@ open class LottieAnimationView: LottieAnimationViewBase {
         position.y = bounds.maxY - animation.bounds.midY
         xform = CATransform3DIdentity
 
-      #if os(iOS) || os(tvOS)
+      #if canImport(UIKit)
       @unknown default:
         logger.assertionFailure("unsupported contentMode: \(contentMode.rawValue)")
         xform = CATransform3DIdentity
@@ -969,7 +917,7 @@ open class LottieAnimationView: LottieAnimationViewBase {
     // If layout is changed without animation, explicitly set animation duration to 0.0
     // inside CATransaction to avoid unwanted artifacts.
     /// Check if any animation exist on the view's layer, and match it.
-    if let key = viewLayer?.animationKeys()?.first, let animation = viewLayer?.animation(forKey: key) {
+    if let key = lottieAnimationLayer.animationKeys()?.first, let animation = lottieAnimationLayer.animation(forKey: key) {
       // The layout is happening within an animation block. Grab the animation data.
 
       let positionKey = "LayoutPositionAnimation"
@@ -993,11 +941,7 @@ open class LottieAnimationView: LottieAnimationViewBase {
 
       animationLayer.position = position
       animationLayer.transform = xform
-      #if os(OSX)
-      animationLayer.anchorPoint = layer?.anchorPoint ?? CGPoint.zero
-      #else
-      animationLayer.anchorPoint = layer.anchorPoint
-      #endif
+      animationLayer.anchorPoint = lottieAnimationLayer.anchorPoint
       animationLayer.add(positionAnimation, forKey: positionKey)
       animationLayer.add(xformAnimation, forKey: transformKey)
     } else {
@@ -1020,38 +964,21 @@ open class LottieAnimationView: LottieAnimationViewBase {
     }
 
     if shouldForceUpdates {
-      animationLayer.forceDisplayUpdate()
+      lottieAnimationLayer.forceDisplayUpdate()
     }
   }
 
   func updateRasterizationState() {
-    if isAnimationPlaying {
-      animationLayer?.shouldRasterize = false
+    if lottieAnimationLayer.isAnimationPlaying {
+      lottieAnimationLayer.animationLayer?.shouldRasterize = false
     } else {
-      animationLayer?.shouldRasterize = shouldRasterizeWhenIdle
+      lottieAnimationLayer.animationLayer?.shouldRasterize = lottieAnimationLayer.shouldRasterizeWhenIdle
     }
   }
 
   /// Updates the animation frame. Does not affect any current animations
   func updateAnimationFrame(_ newFrame: CGFloat) {
-    // In performance tests, we have to wrap the animation view setup
-    // in a `CATransaction` in order for the layers to be deallocated at
-    // the correct time. The `CATransaction`s in this method interfere
-    // with the ones managed by the performance test, and aren't actually
-    // necessary in a headless environment, so we disable them.
-    if TestHelpers.performanceTestsAreRunning {
-      animationLayer?.currentFrame = newFrame
-      animationLayer?.forceDisplayUpdate()
-      return
-    }
-
-    CATransaction.begin()
-    CATransaction.setCompletionBlock {
-      self.animationLayer?.forceDisplayUpdate()
-    }
-    CATransaction.setDisableActions(true)
-    animationLayer?.currentFrame = newFrame
-    CATransaction.commit()
+    lottieAnimationLayer.updateAnimationFrame(newFrame)
   }
 
   @objc
@@ -1076,438 +1003,34 @@ open class LottieAnimationView: LottieAnimationViewBase {
     }
   }
 
-  /// Updates an in flight animation.
   func updateInFlightAnimation() {
-    guard let animationContext = animationContext else { return }
-
-    guard animationContext.closure.animationState != .complete else {
-      // Tried to re-add an already completed animation. Cancel.
-      self.animationContext = nil
-      return
-    }
-
-    /// Tell existing context to ignore its closure
-    animationContext.closure.ignoreDelegate = true
-
-    /// Make a new context, stealing the completion block from the previous.
-    let newContext = AnimationContext(
-      playFrom: animationContext.playFrom,
-      playTo: animationContext.playTo,
-      closure: animationContext.closure.completionBlock)
-
-    /// Remove current animation, and freeze the current frame.
-    let pauseFrame = realtimeAnimationFrame
-    animationLayer?.removeAnimation(forKey: activeAnimationName)
-    animationLayer?.currentFrame = pauseFrame
+    lottieAnimationLayer.updateInFlightAnimation()
+  }
 
-    addNewAnimationForContext(newContext)
+  func loadAnimation(_ animationSource: LottieAnimationSource?) {
+    lottieAnimationLayer.loadAnimation(animationSource)
   }
 
   // MARK: Fileprivate
 
-  /// Context describing the animation that is currently playing in this `LottieAnimationView`
-  ///  - When non-nil, an animation is currently playing in this view. Otherwise,
-  ///    the view is paused on a specific frame.
-  fileprivate var animationContext: AnimationContext?
-
-  fileprivate var _activeAnimationName: String = LottieAnimationView.animationName
-  fileprivate var animationID = 0
-
   fileprivate var waitingToPlayAnimation = false
 
-  fileprivate var activeAnimationName: String {
-    switch animationLayer?.primaryAnimationKey {
-    case .specific(let animationKey):
-      return animationKey
-    case .managed, nil:
-      return _activeAnimationName
-    }
-  }
-
-  fileprivate func makeAnimationLayer(usingEngine renderingEngine: RenderingEngineOption) {
-    /// Remove current animation if any
-    removeCurrentAnimation()
-
-    if let oldAnimation = animationLayer {
-      oldAnimation.removeFromSuperlayer()
-      animationLayer = nil
-    }
-
-    invalidateIntrinsicContentSize()
-
-    guard let animation = animation else {
-      return
-    }
-
-    let rootAnimationLayer: RootAnimationLayer?
-    switch renderingEngine {
-    case .automatic:
-      rootAnimationLayer = makeAutomaticEngineLayer(for: animation)
-    case .specific(.coreAnimation):
-      rootAnimationLayer = makeCoreAnimationLayer(for: animation)
-    case .specific(.mainThread):
-      rootAnimationLayer = makeMainThreadAnimationLayer(for: animation)
-    }
-
-    guard let animationLayer = rootAnimationLayer else {
-      return
-    }
-
-    animationLayer.animationView = self
-    animationLayer.renderScale = screenScale
-
-    viewLayer?.addSublayer(animationLayer)
-    self.animationLayer = animationLayer
-    reloadImages()
-    animationLayer.setNeedsDisplay()
-    setNeedsLayout()
-    currentFrame = CGFloat(animation.startFrame)
-  }
-
-  fileprivate func makeMainThreadAnimationLayer(for animation: LottieAnimation) -> MainThreadAnimationLayer {
-    MainThreadAnimationLayer(
-      animation: animation,
-      imageProvider: imageProvider.cachedImageProvider,
-      textProvider: textProvider,
-      fontProvider: fontProvider,
-      maskAnimationToBounds: maskAnimationToBounds,
-      logger: logger)
-  }
-
-  fileprivate func makeCoreAnimationLayer(for animation: LottieAnimation) -> CoreAnimationLayer? {
-    do {
-      let coreAnimationLayer = try CoreAnimationLayer(
-        animation: animation,
-        imageProvider: imageProvider.cachedImageProvider,
-        textProvider: textProvider,
-        fontProvider: fontProvider,
-        maskAnimationToBounds: maskAnimationToBounds,
-        compatibilityTrackerMode: .track,
-        logger: logger)
-
-      coreAnimationLayer.didSetUpAnimation = { [logger] compatibilityIssues in
-        logger.assert(
-          compatibilityIssues.isEmpty,
-          "Encountered Core Animation compatibility issues while setting up animation:\n"
-            + compatibilityIssues.map { $0.description }.joined(separator: "\n") + "\n\n"
-            + """
-              This animation cannot be rendered correctly by the Core Animation engine.
-              To resolve this issue, you can use `RenderingEngineOption.automatic`, which automatically falls back
-              to the Main Thread rendering engine when necessary, or just use `RenderingEngineOption.mainThread`.
-
-              """)
-      }
-
-      return coreAnimationLayer
-    } catch {
-      // This should never happen, because we initialize the `CoreAnimationLayer` with
-      // `CompatibilityTracker.Mode.track` (which reports errors in `didSetUpAnimation`,
-      // not by throwing).
-      logger.assertionFailure("Encountered unexpected error \(error)")
-      return nil
-    }
-  }
-
-  fileprivate func makeAutomaticEngineLayer(for animation: LottieAnimation) -> CoreAnimationLayer? {
-    do {
-      // Attempt to set up the Core Animation layer. This can either throw immediately in `init`,
-      // or throw an error later in `CALayer.display()` that will be reported in `didSetUpAnimation`.
-      let coreAnimationLayer = try CoreAnimationLayer(
-        animation: animation,
-        imageProvider: imageProvider.cachedImageProvider,
-        textProvider: textProvider,
-        fontProvider: fontProvider,
-        maskAnimationToBounds: maskAnimationToBounds,
-        compatibilityTrackerMode: .abort,
-        logger: logger)
-
-      coreAnimationLayer.didSetUpAnimation = { [weak self] issues in
-        self?.automaticEngineLayerDidSetUpAnimation(issues)
-      }
-
-      return coreAnimationLayer
-    } catch {
-      if case CompatibilityTracker.Error.encounteredCompatibilityIssue(let compatibilityIssue) = error {
-        automaticEngineLayerDidSetUpAnimation([compatibilityIssue])
-      } else {
-        // This should never happen, because we expect `CoreAnimationLayer` to only throw
-        // `CompatibilityTracker.Error.encounteredCompatibilityIssue` errors.
-        logger.assertionFailure("Encountered unexpected error \(error)")
-        automaticEngineLayerDidSetUpAnimation([])
-      }
-
-      return nil
-    }
-  }
-
-  // Handles any compatibility issues with the Core Animation engine
-  // by falling back to the Main Thread engine
-  fileprivate func automaticEngineLayerDidSetUpAnimation(_ compatibilityIssues: [CompatibilityIssue]) {
-    // If there weren't any compatibility issues, then there's nothing else to do
-    if compatibilityIssues.isEmpty {
-      return
-    }
-
-    logger.warn(
-      "Encountered Core Animation compatibility issue while setting up animation:\n"
-        + compatibilityIssues.map { $0.description }.joined(separator: "\n") + "\n"
-        + """
-          This animation may have additional compatibility issues, but animation setup was cancelled early to avoid wasted work.
-
-          Automatically falling back to Main Thread rendering engine. This fallback comes with some additional performance
-          overhead, which can be reduced by manually specifying that this animation should always use the Main Thread engine.
-
-          """)
-
-    let animationContext = animationContext
-    let currentFrame = currentFrame
-
-    // Disable the completion handler delegate before tearing down the `CoreAnimationLayer`
-    // and building the `MainThreadAnimationLayer`. Otherwise deinitializing the
-    // `CoreAnimationLayer` would trigger the animation completion handler even though
-    // the animation hasn't even started playing yet.
-    animationContext?.closure.ignoreDelegate = true
-
-    makeAnimationLayer(usingEngine: .mainThread)
-
-    // Set up the Main Thread animation layer using the same configuration that
-    // was being used by the previous Core Animation layer
-    self.currentFrame = currentFrame
-
-    if let animationContext = animationContext {
-      // `AnimationContext.closure` (`AnimationCompletionDelegate`) is a reference type
-      // that is the animation layer's `CAAnimationDelegate`, and holds a reference to
-      // the animation layer. Reusing a single instance across different animation layers
-      // can cause the animation setup to fail, so we create a copy of the `animationContext`:
-      addNewAnimationForContext(AnimationContext(
-        playFrom: animationContext.playFrom,
-        playTo: animationContext.playTo,
-        closure: animationContext.closure.completionBlock))
-    }
-  }
-
   fileprivate func updateAnimationForBackgroundState() {
-    if let currentContext = animationContext {
-      switch backgroundBehavior {
-      case .stop:
-        removeCurrentAnimation()
-        updateAnimationFrame(currentContext.playFrom)
-      case .pause:
-        removeCurrentAnimation()
-      case .pauseAndRestore:
-        currentContext.closure.ignoreDelegate = true
-        removeCurrentAnimation()
-        /// Keep the stale context around for when the app enters the foreground.
-        animationContext = currentContext
-      case .forceFinish:
-        removeCurrentAnimation()
-        updateAnimationFrame(currentContext.playTo)
-      case .continuePlaying:
-        break
-      }
-    }
+    lottieAnimationLayer.updateAnimationForBackgroundState()
   }
 
   fileprivate func updateAnimationForForegroundState() {
-    if let currentContext = animationContext {
-      if waitingToPlayAnimation {
-        waitingToPlayAnimation = false
-        addNewAnimationForContext(currentContext)
-      } else if backgroundBehavior == .pauseAndRestore {
-        /// Restore animation from saved state
-        updateInFlightAnimation()
-      }
+    let wasWaitingToPlayAnimation = waitingToPlayAnimation
+    if waitingToPlayAnimation {
+      waitingToPlayAnimation = false
     }
-  }
-
-  /// Removes the current animation and pauses the animation at the current frame
-  /// if necessary before setting up a new animation.
-  ///  - This is not necessary with the Core Animation engine, and skipping
-  ///    this step lets us avoid building the animations twice (once paused
-  ///    and once again playing)
-  ///  - This method should only be called immediately before setting up another
-  ///    animation -- otherwise this LottieAnimationView could be put in an inconsistent state.
-  fileprivate func removeCurrentAnimationIfNecessary() {
-    switch currentRenderingEngine {
-    case .mainThread:
-      removeCurrentAnimation()
-    case .coreAnimation, nil:
-      // We still need to remove the `animationContext`, since it should only be present
-      // when an animation is actually playing. Without this calling `removeCurrentAnimationIfNecessary()`
-      // and then setting the animation to a specific paused frame would put this
-      // `LottieAnimationView` in an inconsistent state.
-      animationContext = nil
-    }
-  }
-
-  /// Stops the current in flight animation and freezes the animation in its current state.
-  fileprivate func removeCurrentAnimation() {
-    guard animationContext != nil else { return }
-    let pauseFrame = realtimeAnimationFrame
-    animationLayer?.removeAnimation(forKey: activeAnimationName)
-    updateAnimationFrame(pauseFrame)
-    animationContext = nil
-  }
-
-  /// Adds animation to animation layer and sets the delegate. If animation layer or animation are nil, exits.
-  fileprivate func addNewAnimationForContext(_ animationContext: AnimationContext) {
-    guard let animationlayer = animationLayer, let animation = animation else {
-      return
-    }
-
-    self.animationContext = animationContext
-
-    switch currentRenderingEngine {
-    case .mainThread:
-      guard window != nil else {
-        waitingToPlayAnimation = true
-        return
-      }
-
-    case .coreAnimation, nil:
-      // The Core Animation engine automatically batches animation setup to happen
-      // in `CALayer.display()`, which won't be called until the layer is on-screen,
-      // so we don't need to defer animation setup at this layer.
-      break
-    }
-
-    animationID = animationID + 1
-    _activeAnimationName = LottieAnimationView.animationName + String(animationID)
-
-    if let coreAnimationLayer = animationlayer as? CoreAnimationLayer {
-      var animationContext = animationContext
-
-      // Core Animation doesn't natively support negative speed values,
-      // so instead we can swap `playFrom` / `playTo`
-      if animationSpeed < 0 {
-        let temp = animationContext.playFrom
-        animationContext.playFrom = animationContext.playTo
-        animationContext.playTo = temp
-      }
-
-      var timingConfiguration = CoreAnimationLayer.CAMediaTimingConfiguration(
-        autoreverses: loopMode.caAnimationConfiguration.autoreverses,
-        repeatCount: loopMode.caAnimationConfiguration.repeatCount,
-        speed: abs(Float(animationSpeed)))
-
-      // The animation should start playing from the `currentFrame`,
-      // if `currentFrame` is included in the time range being played.
-      let lowerBoundTime = min(animationContext.playFrom, animationContext.playTo)
-      let upperBoundTime = max(animationContext.playFrom, animationContext.playTo)
-      if (lowerBoundTime ..< upperBoundTime).contains(round(currentFrame)) {
-        // We have to configure this differently depending on the loop mode:
-        switch loopMode {
-        // When playing exactly once (and not looping), we can just set the
-        // `playFrom` time to be the `currentFrame`. Since the animation duration
-        // is based on `playFrom` and `playTo`, this automatically truncates the
-        // duration (so the animation stops playing at `playFrom`).
-        //  - Don't do this if the animation is already at that frame
-        //    (e.g. playing from 100% to 0% when the animation is already at 0%)
-        //    since that would cause the animation to not play at all.
-        case .playOnce:
-          if animationContext.playTo != currentFrame {
-            animationContext.playFrom = currentFrame
-          }
-
-        // When looping, we specifically _don't_ want to affect the duration of the animation,
-        // since that would affect the duration of all subsequent loops. We just want to adjust
-        // the duration of the _first_ loop. Instead of setting `playFrom`, we just add a `timeOffset`
-        // so the first loop begins at `currentTime` but all subsequent loops are the standard duration.
-        default:
-          if animationSpeed < 0 {
-            timingConfiguration.timeOffset = animation.time(forFrame: animationContext.playFrom) - currentTime
-          } else {
-            timingConfiguration.timeOffset = currentTime - animation.time(forFrame: animationContext.playFrom)
-          }
-        }
-      }
-
-      // If attempting to play a zero-duration animation, just pause on that single frame instead
-      if animationContext.playFrom == animationContext.playTo {
-        currentFrame = animationContext.playTo
-        animationContext.closure.completionBlock?(true)
-        return
-      }
-
-      coreAnimationLayer.playAnimation(configuration: .init(
-        animationContext: animationContext,
-        timingConfiguration: timingConfiguration))
-
-      return
-    }
-
-    /// At this point there is no animation on animationLayer and its state is set.
-
-    let framerate = animation.framerate
-
-    let playFrom = animationContext.playFrom.clamp(animation.startFrame, animation.endFrame)
-    let playTo = animationContext.playTo.clamp(animation.startFrame, animation.endFrame)
-
-    let duration = ((max(playFrom, playTo) - min(playFrom, playTo)) / CGFloat(framerate))
-
-    let playingForward: Bool =
-      (
-        (animationSpeed > 0 && playFrom < playTo) ||
-          (animationSpeed < 0 && playTo < playFrom))
-
-    var startFrame = currentFrame.clamp(min(playFrom, playTo), max(playFrom, playTo))
-    if startFrame == playTo {
-      startFrame = playFrom
-    }
-
-    let timeOffset: TimeInterval = playingForward
-      ? Double(startFrame - min(playFrom, playTo)) / framerate
-      : Double(max(playFrom, playTo) - startFrame) / framerate
-
-    let layerAnimation = CABasicAnimation(keyPath: "currentFrame")
-    layerAnimation.fromValue = playFrom
-    layerAnimation.toValue = playTo
-    layerAnimation.speed = Float(animationSpeed)
-    layerAnimation.duration = TimeInterval(duration)
-    layerAnimation.fillMode = CAMediaTimingFillMode.both
-    layerAnimation.repeatCount = loopMode.caAnimationConfiguration.repeatCount
-    layerAnimation.autoreverses = loopMode.caAnimationConfiguration.autoreverses
-
-    layerAnimation.isRemovedOnCompletion = false
-    if timeOffset != 0 {
-      let currentLayerTime = viewLayer?.convertTime(CACurrentMediaTime(), from: nil) ?? 0
-      layerAnimation.beginTime = currentLayerTime - (timeOffset * 1 / Double(abs(animationSpeed)))
-    }
-    layerAnimation.delegate = animationContext.closure
-    animationContext.closure.animationLayer = animationlayer
-    animationContext.closure.animationKey = activeAnimationName
-
-    animationlayer.add(layerAnimation, forKey: activeAnimationName)
-    updateRasterizationState()
+    lottieAnimationLayer.updateAnimationForForegroundState(wasWaitingToPlayAnimation: wasWaitingToPlayAnimation)
   }
 
   // MARK: Private
 
-  static private let animationName = "Lottie"
+  // The backing CALayer for this animation view.
+  private let lottieAnimationLayer: LottieAnimationLayer
 
   private let logger: LottieLogger
-
-  /// The `LottieBackgroundBehavior` that was specified manually by setting `self.backgroundBehavior`
-  private var _backgroundBehavior: LottieBackgroundBehavior?
-
-}
-
-// MARK: - LottieLoopMode + caAnimationConfiguration
-
-extension LottieLoopMode {
-  /// The `CAAnimation` configuration that reflects this mode
-  var caAnimationConfiguration: (repeatCount: Float, autoreverses: Bool) {
-    switch self {
-    case .playOnce:
-      return (repeatCount: 1, autoreverses: false)
-    case .loop:
-      return (repeatCount: .greatestFiniteMagnitude, autoreverses: false)
-    case .autoReverse:
-      return (repeatCount: .greatestFiniteMagnitude, autoreverses: true)
-    case .repeat(let amount):
-      return (repeatCount: amount, autoreverses: false)
-    case .repeatBackwards(let amount):
-      return (repeatCount: amount, autoreverses: true)
-    }
-  }
 }