lottie-ios 3.2.3 → 3.4.0

package/Sources/Public/Keyframes/Keyframe.swift

@@ -0,0 +1,92 @@
+// Created by Cal Stephens on 1/24/22.
+// Copyright © 2022 Airbnb Inc. All rights reserved.
+
+// MARK: - Keyframe
+
+/// A keyframe with a single value, and timing information
+/// about when the value should be displayed and how it
+/// should be interpolated.
+public final class Keyframe<T> {
+
+  // MARK: Lifecycle
+
+  /// Initialize a value-only keyframe with no time data.
+  public init(
+    _ value: T,
+    spatialInTangent: Vector3D? = nil,
+    spatialOutTangent: Vector3D? = nil)
+  {
+    self.value = value
+    time = 0
+    isHold = true
+    inTangent = nil
+    outTangent = nil
+    self.spatialInTangent = spatialInTangent
+    self.spatialOutTangent = spatialOutTangent
+  }
+
+  /// Initialize a keyframe
+  public init(
+    value: T,
+    time: AnimationFrameTime,
+    isHold: Bool = false,
+    inTangent: Vector2D? = nil,
+    outTangent: Vector2D? = nil,
+    spatialInTangent: Vector3D? = nil,
+    spatialOutTangent: Vector3D? = nil)
+  {
+    self.value = value
+    self.time = time
+    self.isHold = isHold
+    self.outTangent = outTangent
+    self.inTangent = inTangent
+    self.spatialInTangent = spatialInTangent
+    self.spatialOutTangent = spatialOutTangent
+  }
+
+  // MARK: Public
+
+  /// The value of the keyframe
+  public let value: T
+  /// The time in frames of the keyframe.
+  public let time: AnimationFrameTime
+  /// A hold keyframe freezes interpolation until the next keyframe that is not a hold.
+  public let isHold: Bool
+  /// The in tangent for the time interpolation curve.
+  public let inTangent: Vector2D?
+  /// The out tangent for the time interpolation curve.
+  public let outTangent: Vector2D?
+
+  /// The spatial in tangent of the vector.
+  public let spatialInTangent: Vector3D?
+  /// The spatial out tangent of the vector.
+  public let spatialOutTangent: Vector3D?
+}
+
+// MARK: Equatable
+
+extension Keyframe: Equatable where T: Equatable {
+  public static func == (lhs: Keyframe<T>, rhs: Keyframe<T>) -> Bool {
+    lhs.value == rhs.value
+      && lhs.time == rhs.time
+      && lhs.isHold == rhs.isHold
+      && lhs.inTangent == rhs.inTangent
+      && lhs.outTangent == rhs.outTangent
+      && lhs.spatialInTangent == rhs.spatialOutTangent
+      && lhs.spatialOutTangent == rhs.spatialOutTangent
+  }
+}
+
+// MARK: Hashable
+
+extension Keyframe: Hashable where T: Hashable {
+  public func hash(into hasher: inout Hasher) {
+    hasher.combine(value)
+    hasher.combine(time)
+    hasher.combine(isHold)
+    hasher.combine(inTangent)
+    hasher.combine(outTangent)
+    hasher.combine(spatialInTangent)
+    hasher.combine(spatialOutTangent)
+  }
+}

package/Sources/Public/Logging/LottieLogger.swift

@@ -0,0 +1,124 @@
+// Created by eric_horacek on 12/9/20.
+// Copyright © 2020 Airbnb Inc. All rights reserved.
+
+// MARK: - LottieLogger
+
+/// A shared logger that allows consumers to intercept Lottie assertions and warning messages to pipe
+/// into their own logging systems.
+public final class LottieLogger {
+
+  // MARK: Lifecycle
+
+  public init(
+    assert: @escaping Assert = Swift.assert,
+    assertionFailure: @escaping AssertionFailure = Swift.assertionFailure,
+    warn: @escaping Warn = { message, _, _ in
+      #if DEBUG
+      // swiftlint:disable:next no_direct_standard_out_logs
+      print(message())
+      #endif
+    },
+    info: @escaping Info = { message in
+      #if DEBUG
+      // swiftlint:disable:next no_direct_standard_out_logs
+      print(message())
+      #endif
+    })
+  {
+    _assert = assert
+    _assertionFailure = assertionFailure
+    _warn = warn
+    _info = info
+  }
+
+  // MARK: Public
+
+  /// Logs that an assertion occurred.
+  public typealias Assert = (
+    _ condition: @autoclosure () -> Bool,
+    _ message: @autoclosure () -> String,
+    _ fileID: StaticString,
+    _ line: UInt)
+    -> Void
+
+  /// Logs that an assertion failure occurred.
+  public typealias AssertionFailure = (
+    _ message: @autoclosure () -> String,
+    _ fileID: StaticString,
+    _ line: UInt)
+    -> Void
+
+  /// Logs a warning message.
+  public typealias Warn = (
+    _ message: @autoclosure () -> String,
+    _ fileID: StaticString,
+    _ line: UInt)
+    -> Void
+
+  /// Prints a purely informational message.
+  public typealias Info = (_ message: @autoclosure () -> String) -> Void
+
+  /// The shared instance used to log Lottie assertions and warnings.
+  ///
+  /// Set this to a new logger instance to intercept assertions and warnings logged by Lottie.
+  public static var shared = LottieLogger()
+
+  /// Logs that an assertion occurred.
+  public func assert(
+    _ condition: @autoclosure () -> Bool,
+    _ message: @autoclosure () -> String = String(),
+    fileID: StaticString = #fileID,
+    line: UInt = #line)
+  {
+    _assert(condition(), message(), fileID, line)
+  }
+
+  /// Logs that an assertion failure occurred.
+  public func assertionFailure(
+    _ message: @autoclosure () -> String = String(),
+    fileID: StaticString = #fileID,
+    line: UInt = #line)
+  {
+    _assertionFailure(message(), fileID, line)
+  }
+
+  /// Logs a warning message.
+  public func warn(
+    _ message: @autoclosure () -> String = String(),
+    fileID: StaticString = #fileID,
+    line: UInt = #line)
+  {
+    _warn(message(), fileID, line)
+  }
+
+  /// Logs a purely informational message.
+  public func info(_ message: @autoclosure () -> String = String()) {
+    _info(message())
+  }
+
+  // MARK: Private
+
+  private let _assert: Assert
+  private let _assertionFailure: AssertionFailure
+  private let _warn: Warn
+  private let _info: Info
+
+}
+
+// MARK: - LottieLogger + printToConsole
+
+extension LottieLogger {
+  /// A `LottieLogger` instance that always prints to the console (by calling `print`)
+  /// instead of calling `assert` / `assertionFailure`, which halt execution in debug builds.
+  public static var printToConsole: LottieLogger {
+    LottieLogger(
+      assert: { condition, message, _, _ in
+        if !condition() {
+          print(message())
+        }
+      },
+      assertionFailure: { message, _, _ in
+        print(message())
+      })
+  }
+}

package/Sources/Public/LottieConfiguration.swift

@@ -0,0 +1,143 @@
+// Created by Cal Stephens on 12/13/21.
+// Copyright © 2021 Airbnb Inc. All rights reserved.
+
+// MARK: - LottieConfiguration
+
+/// Global configuration options for Lottie animations
+public struct LottieConfiguration: Hashable {
+
+  public init(
+    renderingEngine: RenderingEngineOption = .mainThread,
+    decodingStrategy: DecodingStrategy = .codable)
+  {
+    self.renderingEngine = renderingEngine
+    self.decodingStrategy = decodingStrategy
+  }
+
+  /// The global configuration of Lottie,
+  /// which applies to all `AnimationView`s by default.
+  public static var shared = LottieConfiguration()
+
+  /// The rendering engine implementation to use when displaying an animation
+  public var renderingEngine: RenderingEngineOption
+
+  /// The decoding implementation to use when parsing an animation JSON file
+  public var decodingStrategy: DecodingStrategy
+
+}
+
+// MARK: - RenderingEngineOption
+
+public enum RenderingEngineOption: Hashable {
+  /// Uses the Core Animation engine for supported animations, and falls back to using
+  /// the Main Thread engine for animations that use features not supported by the
+  /// Core Animation engine.
+  case automatic
+
+  /// Uses the specified rendering engine
+  case specific(RenderingEngine)
+
+  /// The Main Thread rendering engine, which supports all Lottie features
+  /// but runs on the main thread, which comes with some CPU overhead and
+  /// can cause the animation to play at a low framerate when the CPU is busy.
+  public static var mainThread: RenderingEngineOption { .specific(.mainThread) }
+
+  /// The Core Animation rendering engine, that animates using Core Animation
+  /// and has better performance characteristics than the Main Thread engine,
+  /// but doesn't support all Lottie features.
+  public static var coreAnimation: RenderingEngineOption { .specific(.coreAnimation) }
+}
+
+// MARK: - RenderingEngine
+
+/// The rendering engine implementation to use when displaying an animation
+public enum RenderingEngine: Hashable {
+  /// The Main Thread rendering engine, which supports all Lottie features
+  /// but runs on the main thread, which comes with some CPU overhead and
+  /// can cause the animation to play at a low framerate when the CPU is busy.
+  case mainThread
+
+  /// The Core Animation rendering engine, that animates using Core Animation
+  /// and has better performance characteristics than the Main Thread engine,
+  /// but doesn't support all Lottie features.
+  case coreAnimation
+}
+
+// MARK: - RenderingEngineOption + RawRepresentable, CustomStringConvertible
+
+extension RenderingEngineOption: RawRepresentable, CustomStringConvertible {
+
+  // MARK: Lifecycle
+
+  public init?(rawValue: String) {
+    if rawValue == "Automatic" {
+      self = .automatic
+    } else if let engine = RenderingEngine(rawValue: rawValue) {
+      self = .specific(engine)
+    } else {
+      return nil
+    }
+  }
+
+  // MARK: Public
+
+  public var rawValue: String {
+    switch self {
+    case .automatic:
+      return "Automatic"
+    case .specific(let engine):
+      return engine.rawValue
+    }
+  }
+
+  public var description: String {
+    rawValue
+  }
+
+}
+
+// MARK: - RenderingEngine + RawRepresentable, CustomStringConvertible
+
+extension RenderingEngine: RawRepresentable, CustomStringConvertible {
+
+  // MARK: Lifecycle
+
+  public init?(rawValue: String) {
+    switch rawValue {
+    case "Main Thread":
+      self = .mainThread
+    case "Core Animation":
+      self = .coreAnimation
+    default:
+      return nil
+    }
+  }
+
+  // MARK: Public
+
+  public var rawValue: String {
+    switch self {
+    case .mainThread:
+      return "Main Thread"
+    case .coreAnimation:
+      return "Core Animation"
+    }
+  }
+
+  public var description: String {
+    rawValue
+  }
+}
+
+// MARK: - DecodingStrategy
+
+/// How animation files should be decoded
+public enum DecodingStrategy: Hashable {
+  /// Use Codable. This is the default strategy introduced on Lottie 3.
+  case codable
+
+  /// Manually deserialize a dictionary into an Animation.
+  /// This should be at least 2-3x faster than using Codable,
+  /// but since it's manually implemented, there might be issues while it's experimental.
+  case dictionaryBased
+}

package/{lottie-swift/src → Sources}/Public/Primitives/AnimationTime.swift

@@ -5,8 +5,8 @@
 //  Created by Brandon Withrow on 2/6/19.
 //
 
-import Foundation
 import CoreGraphics
+import Foundation
 
 /// Defines animation time in Frames (Seconds * Framerate).
 public typealias AnimationFrameTime = CGFloat

package/{lottie-swift/src → Sources}/Public/Primitives/Color.swift

@@ -7,11 +7,13 @@
 
 import Foundation
 
-public enum ColorFormatDenominator {
+// MARK: - ColorFormatDenominator
+
+public enum ColorFormatDenominator: Hashable {
   case One
   case OneHundred
   case TwoFiftyFive
-  
+
   var value: Double {
     switch self {
     case .One:
@@ -24,18 +26,20 @@ public enum ColorFormatDenominator {
   }
 }
 
-public struct Color {
-  
+// MARK: - Color
+
+public struct Color: Hashable {
+
   public var r: Double
   public var g: Double
   public var b: Double
   public var a: Double
-  
+
   public init(r: Double, g: Double, b: Double, a: Double, denominator: ColorFormatDenominator = .One) {
     self.r = r / denominator.value
     self.g = g / denominator.value
     self.b = b / denominator.value
     self.a = a / denominator.value
   }
-  
+
 }

package/{lottie-swift/src → Sources}/Public/Primitives/Vectors.swift

@@ -7,31 +7,32 @@
 
 import Foundation
 
-public struct Vector1D {
-  
+// MARK: - Vector1D
+
+public struct Vector1D: Hashable {
+
   public init(_ value: Double) {
     self.value = value
   }
-  
+
   public let value: Double
-  
+
 }
 
+// MARK: - Vector3D
+
+/// A three dimensional vector.
+/// These vectors are encoded and decoded from [Double]
+public struct Vector3D: Hashable {
 
-/**
- A three dimensional vector.
- These vectors are encoded and decoded from [Double]
- */
-public struct Vector3D {
-  
   public let x: Double
   public let y: Double
   public let z: Double
-  
+
   public init(x: Double, y: Double, z: Double) {
     self.x = x
     self.y = y
     self.z = z
   }
-  
+
 }

package/Sources/Public/TextProvider/AnimationTextProvider.swift

@@ -0,0 +1,53 @@
+//
+//  AnimationImageProvider.swift
+//  Lottie_iOS
+//
+//  Created by Alexandr Goncharov on 07/06/2019.
+//
+
+import Foundation
+
+// MARK: - AnimationTextProvider
+
+/// Text provider is a protocol that is used to supply text to `AnimationView`.
+public protocol AnimationTextProvider: AnyObject {
+  func textFor(keypathName: String, sourceText: String) -> String
+}
+
+// MARK: - DictionaryTextProvider
+
+/// Text provider that simply map values from dictionary
+public final class DictionaryTextProvider: AnimationTextProvider {
+
+  // MARK: Lifecycle
+
+  public init(_ values: [String: String]) {
+    self.values = values
+  }
+
+  // MARK: Public
+
+  public func textFor(keypathName: String, sourceText: String) -> String {
+    values[keypathName] ?? sourceText
+  }
+
+  // MARK: Internal
+
+  let values: [String: String]
+}
+
+// MARK: - DefaultTextProvider
+
+/// Default text provider. Uses text in the animation file
+public final class DefaultTextProvider: AnimationTextProvider {
+
+  // MARK: Lifecycle
+
+  public init() {}
+
+  // MARK: Public
+
+  public func textFor(keypathName _: String, sourceText: String) -> String {
+    sourceText
+  }
+}

package/{lottie-swift/src → Sources}/Public/iOS/AnimatedButton.swift

@@ -8,40 +8,45 @@
 import Foundation
 #if os(iOS) || os(tvOS) || os(watchOS) || targetEnvironment(macCatalyst)
 import UIKit
-/**
- An interactive button that plays an animation when pressed.
- */
-final public class AnimatedButton: AnimatedControl {
-  
+/// An interactive button that plays an animation when pressed.
+open class AnimatedButton: AnimatedControl {
+
+  // MARK: Lifecycle
+
+  public override init(
+    animation: Animation,
+    configuration: LottieConfiguration = .shared)
+  {
+    super.init(animation: animation, configuration: configuration)
+    accessibilityTraits = UIAccessibilityTraits.button
+  }
+
+  public override init() {
+    super.init()
+    accessibilityTraits = UIAccessibilityTraits.button
+  }
+
+  required public init?(coder aDecoder: NSCoder) {
+    super.init(coder: aDecoder)
+  }
+
+  // MARK: Public
+
   /// 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) {
+    if
+      let start = animationView.progressTime(forMarker: fromName),
+      let end = animationView.progressTime(forMarker: toName)
+    {
       rangesForEvents[event.rawValue] = (from: start, to: end)
     }
   }
-  
-  public override init(animation: Animation) {
-    super.init(animation: animation)
-    self.accessibilityTraits = UIAccessibilityTraits.button
-  }
-  
-  public override init() {
-    super.init()
-    self.accessibilityTraits = UIAccessibilityTraits.button
-  }
 
-  fileprivate var rangesForEvents: [UInt : (from: CGFloat, to: CGFloat)] = [UIControl.Event.touchUpInside.rawValue : (from: 0, to: 1)]
-  
-  required public init?(coder aDecoder: NSCoder) {
-    super.init(coder: aDecoder)
-  }
-  
   public override func beginTracking(_ touch: UITouch, with event: UIEvent?) -> Bool {
     let _ = super.beginTracking(touch, with: event)
     let touchEvent = UIControl.Event.touchDown
@@ -50,7 +55,7 @@ final public class AnimatedButton: AnimatedControl {
     }
     return true
   }
-  
+
   public override func endTracking(_ touch: UITouch?, with event: UIEvent?) {
     super.endTracking(touch, with: event)
     let touchEvent: UIControl.Event
@@ -59,10 +64,15 @@ final public class AnimatedButton: AnimatedControl {
     } else {
       touchEvent = UIControl.Event.touchUpOutside
     }
-    
+
     if let playrange = rangesForEvents[touchEvent.rawValue] {
       animationView.play(fromProgress: playrange.from, toProgress: playrange.to, loopMode: LottieLoopMode.playOnce)
     }
   }
+
+  // MARK: Fileprivate
+
+  fileprivate var rangesForEvents: [UInt : (from: CGFloat, to: CGFloat)] =
+    [UIControl.Event.touchUpInside.rawValue : (from: 0, to: 1)]
 }
 #endif