Improve SwiftUI APIs for configuring value providers, image providers…

…, etc (#2109)

Example/Example.xcodeproj/project.pbxproj

@@ -430,7 +430,7 @@
 				DEBUG_INFORMATION_FORMAT = dwarf;
 				GCC_C_LANGUAGE_STANDARD = gnu11;
 				INFOPLIST_FILE = iOS/Info.plist;
-				IPHONEOS_DEPLOYMENT_TARGET = 15.0;
+				IPHONEOS_DEPLOYMENT_TARGET = 16.0;
 				LD_RUNPATH_SEARCH_PATHS = (
 					"$(inherited)",
 					"@executable_path/Frameworks",
@@ -460,7 +460,7 @@
 				CODE_SIGN_STYLE = Automatic;
 				GCC_C_LANGUAGE_STANDARD = gnu11;
 				INFOPLIST_FILE = iOS/Info.plist;
-				IPHONEOS_DEPLOYMENT_TARGET = 15.0;
+				IPHONEOS_DEPLOYMENT_TARGET = 16.0;
 				LD_RUNPATH_SEARCH_PATHS = (
 					"$(inherited)",
 					"@executable_path/Frameworks",

Example/Example/AnimationListView.swift

@@ -18,6 +18,7 @@ struct AnimationListView: View {
           case .animation(let animationName, _):
             HStack {
               LottieView(animation: .named(animationName, subdirectory: directory))
+                .imageProvider(.exampleAppSampleImages)
                 .frame(width: 50, height: 50)
                 .padding(EdgeInsets(top: 8, leading: 8, bottom: 8, trailing: 8))
 

Example/Example/AnimationPreviewView.swift

@@ -14,6 +14,7 @@ struct AnimationPreviewView: View {
   var body: some View {
     VStack {
       LottieView(animation: .named(animationName))
+        .imageProvider(.exampleAppSampleImages)
         .resizable()
         .looping()
     }
@@ -33,3 +34,9 @@ extension Color {
     #endif
   }
 }
+
+extension AnimationImageProvider where Self == FilepathImageProvider {
+  static var exampleAppSampleImages: FilepathImageProvider {
+    FilepathImageProvider(filepath: Bundle.main.resourceURL!.appending(path: "Samples/Images"))
+  }
+}

Sources/Public/Animation/LottieAnimationLayer.swift

@@ -296,16 +296,22 @@ public class LottieAnimationLayer: CALayer {
 
   // MARK: Public
 
-  /// The configuration that this `LottieAnimationView` uses when playing its animation
-  public let configuration: LottieConfiguration
-
   /// Value Providers that have been registered using `setValueProvider(_:keypath:)`
   public private(set) var valueProviders = [AnimationKeypath: AnyValueProvider]()
 
   /// A closure called when the animation layer has been loaded.
   /// Will inform the receiver the type of rendering engine that is used for the layer.
   public var animationLayerDidLoad:((_ animationLayer: LottieAnimationLayer, _ renderingEngine: RenderingEngineOption) -> Void)?
 
+  /// The configuration that this `LottieAnimationView` uses when playing its animation
+  public var configuration: LottieConfiguration {
+    didSet {
+      if configuration.renderingEngine != oldValue.renderingEngine {
+        makeAnimationLayer(usingEngine: configuration.renderingEngine)
+      }
+    }
+  }
+
   /// The underlying CALayer created to display the content.
   /// Use this property to change CALayer props like the content's transform, anchor point, etc.
   public var animationLayer: CALayer? { rootAnimationLayer }

Sources/Public/Animation/LottieAnimationView.swift

@@ -304,7 +304,8 @@ open class LottieAnimationView: LottieAnimationViewBase {
 
   /// The configuration that this `LottieAnimationView` uses when playing its animation
   public var configuration: LottieConfiguration {
-    lottieAnimationLayer.configuration
+    get { lottieAnimationLayer.configuration }
+    set { lottieAnimationLayer.configuration = newValue }
   }
 
   /// Value Providers that have been registered using `setValueProvider(_:keypath:)`

Sources/Public/Animation/LottieView.swift

@@ -11,20 +11,9 @@ public struct LottieView: UIViewConfiguringSwiftUIView {
 
   // MARK: Lifecycle
 
-  public init(
-    animation: LottieAnimation?,
-    imageProvider: AnimationImageProvider? = nil,
-    textProvider: AnimationTextProvider? = nil,
-    fontProvider: AnimationFontProvider? = nil,
-    configuration: LottieConfiguration = .shared,
-    accessibilityLabel: String? = nil)
-  {
+  /// Creates a `LottieView` that displays the given animation
+  public init(animation: LottieAnimation?) {
     self.animation = animation
-    self.imageProvider = imageProvider
-    self.textProvider = textProvider
-    self.fontProvider = fontProvider
-    self.configuration = configuration
-    self.accessibilityLabel = accessibilityLabel
   }
 
   // MARK: Public
@@ -34,30 +23,18 @@ public struct LottieView: UIViewConfiguringSwiftUIView {
       LottieAnimationView(
         animation: animation,
         imageProvider: imageProvider,
-        textProvider: textProvider ?? DefaultTextProvider(),
-        fontProvider: fontProvider ?? DefaultFontProvider(),
+        textProvider: textProvider,
+        fontProvider: fontProvider,
         configuration: configuration)
     }
     .sizing(sizing)
     .configure { context in
-      #if os(macOS)
-      context.view.setAccessibilityElement(accessibilityLabel != nil)
-      context.view.setAccessibilityLabel(accessibilityLabel)
-      #else
-      context.view.isAccessibilityElement = accessibilityLabel != nil
-      context.view.accessibilityLabel = accessibilityLabel
-      #endif
-
       // We check referential equality of the animation before updating as updating the
       // animation has a side-effect of rebuilding the animation layer, and it would be
       // prohibitive to do so on every state update.
       if animation !== context.view.animation {
         context.view.animation = animation
       }
-
-      // Technically the image provider, text provider, font provider, and Lottie configuration
-      // could also need to be updated here, but there's no performant way to check their equality,
-      // so we assume they are not.
     }
     .configurations(configurations)
   }
@@ -99,17 +76,102 @@ public struct LottieView: UIViewConfiguringSwiftUIView {
     }
   }
 
+  /// Returns a copy of this view with its accessibility label updated to the given value.
+  public func accessibilityLabel(_ accessibilityLabel: String?) -> Self {
+    configure { view in
+      #if os(macOS)
+      view.setAccessibilityElement(accessibilityLabel != nil)
+      view.setAccessibilityLabel(accessibilityLabel)
+      #else
+      view.isAccessibilityElement = accessibilityLabel != nil
+      view.accessibilityLabel = accessibilityLabel
+      #endif
+    }
+  }
+
+  /// Returns a copt of this view with its `LottieConfiguration` updated to the given value.
+  public func configuration(_ configuration: LottieConfiguration) -> Self {
+    var copy = self
+    copy.configuration = configuration
+
+    copy = copy.configure { view in
+      if view.configuration != configuration {
+        view.configuration = configuration
+      }
+    }
+
+    return copy
+  }
+
+  /// Returns a copy of this view with its image provider updated to the given value.
+  /// The image provider must be `Equatable` to avoid unnecessary state updates / re-renders.
+  public func imageProvider<ImageProvider: AnimationImageProvider & Equatable>(_ imageProvider: ImageProvider) -> Self {
+    var copy = self
+    copy.imageProvider = imageProvider
+
+    copy = copy.configure { view in
+      if (view.imageProvider as? ImageProvider) != imageProvider {
+        view.imageProvider = imageProvider
+      }
+    }
+
+    return copy
+  }
+
+  /// Returns a copy of this view with its text provider updated to the given value.
+  /// The image provider must be `Equatable` to avoid unnecessary state updates / re-renders.
+  public func textProvider<TextProvider: AnimationTextProvider & Equatable>(_ textProvider: TextProvider) -> Self {
+    var copy = self
+    copy.textProvider = textProvider
+
+    copy = copy.configure { view in
+      if (view.textProvider as? TextProvider) != textProvider {
+        view.textProvider = textProvider
+      }
+    }
+
+    return copy
+  }
+
+  /// Returns a copy of this view with its image provider updated to the given value.
+  /// The image provider must be `Equatable` to avoid unnecessary state updates / re-renders.
+  public func fontProvider<FontProvider: AnimationFontProvider & Equatable>(_ fontProvider: FontProvider) -> Self {
+    var copy = self
+    copy.fontProvider = fontProvider
+
+    copy = configure { view in
+      if (view.fontProvider as? FontProvider) != fontProvider {
+        view.fontProvider = fontProvider
+      }
+    }
+
+    return copy
+  }
+
+  /// Returns a copy of this view using the given value provider for the given keypath.
+  /// The value provider must be `Equatable` to avoid unnecessary state updates / re-renders.
+  public func valueProvider<ValueProvider: AnyValueProvider & Equatable>(
+    _ valueProvider: ValueProvider,
+    for keypath: AnimationKeypath)
+    -> Self
+  {
+    configure { view in
+      if (view.valueProviders[keypath] as? ValueProvider) != valueProvider {
+        view.setValueProvider(valueProvider, keypath: keypath)
+      }
+    }
+  }
+
   // MARK: Internal
 
   var configurations = [SwiftUIView<LottieAnimationView, Void>.Configuration]()
 
   // MARK: Private
 
-  private let accessibilityLabel: String?
   private let animation: LottieAnimation?
-  private let imageProvider: Lottie.AnimationImageProvider?
-  private let textProvider: Lottie.AnimationTextProvider?
-  private let fontProvider: Lottie.AnimationFontProvider?
-  private let configuration: LottieConfiguration
+  private var imageProvider: AnimationImageProvider?
+  private var textProvider: AnimationTextProvider = DefaultTextProvider()
+  private var fontProvider: AnimationFontProvider = DefaultFontProvider()
+  private var configuration: LottieConfiguration = .shared
   private var sizing = SwiftUIMeasurementContainerStrategy.automatic
 }

Sources/Public/DynamicProperties/ValueProviders/ColorValueProvider.swift

@@ -8,6 +8,8 @@
 import CoreGraphics
 import Foundation
 
+// MARK: - ColorValueProvider
+
 /// A `ValueProvider` that returns a CGColor Value
 public final class ColorValueProvider: ValueProvider {
 
@@ -18,6 +20,7 @@ public final class ColorValueProvider: ValueProvider {
     self.block = block
     color = LottieColor(r: 0, g: 0, b: 0, a: 1)
     keyframes = nil
+    identity = UUID()
   }
 
   /// Initializes with a single color.
@@ -26,6 +29,7 @@ public final class ColorValueProvider: ValueProvider {
     block = nil
     keyframes = nil
     hasUpdate = true
+    identity = color
   }
 
   /// Initializes with multiple colors, with timing information
@@ -34,6 +38,7 @@ public final class ColorValueProvider: ValueProvider {
     color = LottieColor(r: 0, g: 0, b: 0, a: 1)
     block = nil
     hasUpdate = true
+    identity = keyframes
   }
 
   // MARK: Public
@@ -81,4 +86,13 @@ public final class ColorValueProvider: ValueProvider {
 
   private var block: ColorValueBlock?
   private var keyframes: [Keyframe<LottieColor>]?
+  private var identity: AnyHashable
+}
+
+// MARK: Equatable
+
+extension ColorValueProvider: Equatable {
+  public static func ==(_ lhs: ColorValueProvider, _ rhs: ColorValueProvider) -> Bool {
+    lhs.identity == rhs.identity
+  }
 }

Sources/Public/DynamicProperties/ValueProviders/FloatValueProvider.swift

@@ -8,6 +8,8 @@
 import CoreGraphics
 import Foundation
 
+// MARK: - FloatValueProvider
+
 /// A `ValueProvider` that returns a CGFloat Value
 public final class FloatValueProvider: ValueProvider {
 
@@ -17,13 +19,15 @@ public final class FloatValueProvider: ValueProvider {
   public init(block: @escaping CGFloatValueBlock) {
     self.block = block
     float = 0
+    identity = UUID()
   }
 
   /// Initializes with a single float.
   public init(_ float: CGFloat) {
     self.float = float
     block = nil
     hasUpdate = true
+    identity = float
   }
 
   // MARK: Public
@@ -67,4 +71,13 @@ public final class FloatValueProvider: ValueProvider {
   private var hasUpdate = true
 
   private var block: CGFloatValueBlock?
+  private var identity: AnyHashable
+}
+
+// MARK: Equatable
+
+extension FloatValueProvider: Equatable {
+  public static func ==(_ lhs: FloatValueProvider, _ rhs: FloatValueProvider) -> Bool {
+    lhs.identity == rhs.identity
+  }
 }

Sources/Public/DynamicProperties/ValueProviders/GradientValueProvider.swift

@@ -8,6 +8,8 @@
 import CoreGraphics
 import Foundation
 
+// MARK: - GradientValueProvider
+
 /// A `ValueProvider` that returns a Gradient Color Value.
 public final class GradientValueProvider: ValueProvider {
 
@@ -22,6 +24,7 @@ public final class GradientValueProvider: ValueProvider {
     locationsBlock = locations
     colors = []
     self.locations = []
+    identity = UUID()
   }
 
   /// Initializes with an array of colors.
@@ -31,6 +34,7 @@ public final class GradientValueProvider: ValueProvider {
   {
     self.colors = colors
     self.locations = locations
+    identity = [AnyHashable(colors), AnyHashable(locations)]
     updateValueArray()
     hasUpdate = true
   }
@@ -93,6 +97,8 @@ public final class GradientValueProvider: ValueProvider {
   private var locationsBlock: ColorLocationsBlock?
   private var value: [Double] = []
 
+  private let identity: AnyHashable
+
   private func value(from colors: [LottieColor], locations: [Double]) -> [Double] {
     var colorValues = [Double]()
     var alphaValues = [Double]()
@@ -120,4 +126,11 @@ public final class GradientValueProvider: ValueProvider {
   private func updateValueArray() {
     value = value(from: colors, locations: locations)
   }
+
+}
+
+extension GradientValueProvider {
+  public static func ==(_ lhs: GradientValueProvider, _ rhs: GradientValueProvider) -> Bool {
+    lhs.identity == rhs.identity
+  }
 }