lottie-ios 4.1.2 → 4.2.0

package/Sources/Public/DotLottie/DotLottieFileHelpers.swift

@@ -9,6 +9,77 @@ import Foundation
 
 extension DotLottieFile {
 
+  public enum SynchronouslyBlockingCurrentThread {
+    /// Loads an DotLottie from a specific filepath synchronously. Returns a `Result<DotLottieFile, Error>`
+    /// Please use the asynchronous methods whenever possible. This operation will block the Thread it is running in.
+    ///
+    /// - Parameter filepath: The absolute filepath of the lottie to load. EG "/User/Me/starAnimation.lottie"
+    /// - Parameter dotLottieCache: A cache for holding loaded lotties. Defaults to `LRUDotLottieCache.sharedCache`. Optional.
+    public static func loadedFrom(
+      filepath: String,
+      dotLottieCache: DotLottieCacheProvider? = DotLottieCache.sharedCache)
+      -> Result<DotLottieFile, Error>
+    {
+      /// Check cache for lottie
+      if
+        let dotLottieCache = dotLottieCache,
+        let lottie = dotLottieCache.file(forKey: filepath)
+      {
+        return .success(lottie)
+      }
+
+      do {
+        /// Decode the lottie.
+        let url = URL(fileURLWithPath: filepath)
+        let data = try Data(contentsOf: url)
+        let lottie = try DotLottieFile(data: data, filename: url.deletingPathExtension().lastPathComponent)
+        dotLottieCache?.setFile(lottie, forKey: filepath)
+        return .success(lottie)
+      } catch {
+        /// Decoding Error.
+        return .failure(error)
+      }
+    }
+
+    /// Loads a DotLottie model from a bundle by its name synchronously. Returns a `Result<DotLottieFile, Error>`
+    /// Please use the asynchronous methods whenever possible. This operation will block the Thread it is running in.
+    ///
+    /// - Parameter name: The name of the lottie file without the lottie extension. EG "StarAnimation"
+    /// - Parameter bundle: The bundle in which the lottie is located. Defaults to `Bundle.main`
+    /// - Parameter subdirectory: A subdirectory in the bundle in which the lottie is located. Optional.
+    /// - Parameter dotLottieCache: A cache for holding loaded lotties. Defaults to `LRUDotLottieCache.sharedCache`. Optional.
+    public static func named(
+      _ name: String,
+      bundle: Bundle = Bundle.main,
+      subdirectory: String? = nil,
+      dotLottieCache: DotLottieCacheProvider? = DotLottieCache.sharedCache)
+      -> Result<DotLottieFile, Error>
+    {
+      /// Create a cache key for the lottie.
+      let cacheKey = bundle.bundlePath + (subdirectory ?? "") + "/" + name
+
+      /// Check cache for lottie
+      if
+        let dotLottieCache = dotLottieCache,
+        let lottie = dotLottieCache.file(forKey: cacheKey)
+      {
+        return .success(lottie)
+      }
+
+      do {
+        /// Decode animation.
+        let data = try bundle.dotLottieData(name, subdirectory: subdirectory)
+        let lottie = try DotLottieFile(data: data, filename: name)
+        dotLottieCache?.setFile(lottie, forKey: cacheKey)
+        return .success(lottie)
+      } catch {
+        /// Decoding error.
+        LottieLogger.shared.warn("Error when decoding lottie \"\(name)\": \(error)")
+        return .failure(error)
+      }
+    }
+  }
+
   /// Loads a DotLottie model from a bundle by its name. Returns `nil` if a file is not found.
   ///
   /// - Parameter name: The name of the lottie file without the lottie extension. EG "StarAnimation"
@@ -36,49 +107,25 @@ extension DotLottieFile {
   /// - Parameter bundle: The bundle in which the lottie is located. Defaults to `Bundle.main`
   /// - Parameter subdirectory: A subdirectory in the bundle in which the lottie is located. Optional.
   /// - Parameter dotLottieCache: A cache for holding loaded lotties. Defaults to `LRUDotLottieCache.sharedCache`. Optional.
+  /// - Parameter dispatchQueue: A dispatch queue used to load animations. Defaults to `DispatchQueue.global()`. Optional.
   /// - Parameter handleResult: A closure to be called when the file has loaded.
   public static func named(
     _ name: String,
     bundle: Bundle = Bundle.main,
     subdirectory: String? = nil,
     dotLottieCache: DotLottieCacheProvider? = DotLottieCache.sharedCache,
+    dispatchQueue: DispatchQueue = .global(),
     handleResult: @escaping (Result<DotLottieFile, Error>) -> Void)
   {
-    DispatchQueue.global().async {
-      /// Create a cache key for the lottie.
-      let cacheKey = bundle.bundlePath + (subdirectory ?? "") + "/" + name
+    dispatchQueue.async {
+      let result = SynchronouslyBlockingCurrentThread.named(
+        name,
+        bundle: bundle,
+        subdirectory: subdirectory,
+        dotLottieCache: dotLottieCache)
 
-      /// Check cache for lottie
-      if
-        let dotLottieCache = dotLottieCache,
-        let lottie = dotLottieCache.file(forKey: cacheKey)
-      {
-        DispatchQueue.main.async {
-          /// If found, return the lottie.
-          handleResult(.success(lottie))
-        }
-        return
-      }
-
-      do {
-        /// Decode animation.
-        guard let data = try bundle.dotLottieData(name, subdirectory: subdirectory) else {
-          DispatchQueue.main.async {
-            handleResult(.failure(DotLottieError.invalidData))
-          }
-          return
-        }
-        let lottie = try DotLottieFile(data: data, filename: name)
-        dotLottieCache?.setFile(lottie, forKey: cacheKey)
-        DispatchQueue.main.async {
-          handleResult(.success(lottie))
-        }
-      } catch {
-        /// Decoding error.
-        LottieLogger.shared.warn("Error when decoding lottie \"\(name)\": \(error)")
-        DispatchQueue.main.async {
-          handleResult(.failure(error))
-        }
+      DispatchQueue.main.async {
+        handleResult(result)
       }
     }
   }
@@ -102,38 +149,21 @@ extension DotLottieFile {
   /// Loads an DotLottie from a specific filepath.
   /// - Parameter filepath: The absolute filepath of the lottie to load. EG "/User/Me/starAnimation.lottie"
   /// - Parameter dotLottieCache: A cache for holding loaded lotties. Defaults to `LRUDotLottieCache.sharedCache`. Optional.
+  /// - Parameter dispatchQueue: A dispatch queue used to load animations. Defaults to `DispatchQueue.global()`. Optional.
   /// - Parameter handleResult: A closure to be called when the file has loaded.
   public static func loadedFrom(
     filepath: String,
     dotLottieCache: DotLottieCacheProvider? = DotLottieCache.sharedCache,
+    dispatchQueue: DispatchQueue = .global(),
     handleResult: @escaping (Result<DotLottieFile, Error>) -> Void)
   {
-    DispatchQueue.global().async {
-      /// Check cache for lottie
-      if
-        let dotLottieCache = dotLottieCache,
-        let lottie = dotLottieCache.file(forKey: filepath)
-      {
-        DispatchQueue.main.async {
-          handleResult(.success(lottie))
-        }
-        return
-      }
+    dispatchQueue.async {
+      let result = SynchronouslyBlockingCurrentThread.loadedFrom(
+        filepath: filepath,
+        dotLottieCache: dotLottieCache)
 
-      do {
-        /// Decode the lottie.
-        let url = URL(fileURLWithPath: filepath)
-        let data = try Data(contentsOf: url)
-        let lottie = try DotLottieFile(data: data, filename: url.deletingPathExtension().lastPathComponent)
-        dotLottieCache?.setFile(lottie, forKey: filepath)
-        DispatchQueue.main.async {
-          handleResult(.success(lottie))
-        }
-      } catch {
-        /// Decoding Error.
-        DispatchQueue.main.async {
-          handleResult(.failure(error))
-        }
+      DispatchQueue.main.async {
+        handleResult(result)
       }
     }
   }
@@ -160,14 +190,16 @@ extension DotLottieFile {
   ///    - Parameter name: The name of the lottie file in the asset catalog. EG "StarAnimation"
   ///    - Parameter bundle: The bundle in which the lottie is located. Defaults to `Bundle.main`
   ///    - Parameter dotLottieCache: A cache for holding loaded lottie files. Defaults to `LRUDotLottieCache.sharedCache` Optional.
+  ///    - Parameter dispatchQueue: A dispatch queue used to load animations. Defaults to `DispatchQueue.global()`. Optional.
   ///    - Parameter handleResult: A closure to be called when the file has loaded.
   public static func asset(
     named name: String,
     bundle: Bundle = Bundle.main,
     dotLottieCache: DotLottieCacheProvider? = DotLottieCache.sharedCache,
+    dispatchQueue: DispatchQueue = .global(),
     handleResult: @escaping (Result<DotLottieFile, Error>) -> Void)
   {
-    DispatchQueue.global().async {
+    dispatchQueue.async {
       /// Create a cache key for the lottie.
       let cacheKey = bundle.bundlePath + "/" + name
 
@@ -183,15 +215,10 @@ extension DotLottieFile {
         return
       }
 
-      /// Load data from Asset
-      guard let data = Data.jsonData(from: name, in: bundle) else {
-        DispatchQueue.main.async {
-          handleResult(.failure(DotLottieError.invalidData))
-        }
-        return
-      }
-
       do {
+        /// Load data from Asset
+        let data = try Data(assetName: name, in: bundle)
+
         /// Decode lottie.
         let lottie = try DotLottieFile(data: data, filename: name)
         dotLottieCache?.setFile(lottie, forKey: cacheKey)
@@ -240,13 +267,13 @@ extension DotLottieFile {
       handleResult(.success(lottie))
     } else {
       let task = session.dataTask(with: url) { data, _, error in
-        guard error == nil, let data = data else {
-          DispatchQueue.main.async {
-            handleResult(.failure(DotLottieError.invalidData))
-          }
-          return
-        }
         do {
+          if let error = error {
+            throw error
+          }
+          guard let data = data else {
+            throw DotLottieError.noDataLoaded
+          }
           let lottie = try DotLottieFile(data: data, filename: url.deletingPathExtension().lastPathComponent)
           DispatchQueue.main.async {
             dotLottieCache?.setFile(lottie, forKey: url.absoluteString)

package/Sources/Public/iOS/Compatibility/CompatibleAnimationView.swift

@@ -90,6 +90,32 @@ public enum CompatibleRenderingEngineOption: Int {
   }
 }
 
+/// An Objective-C compatible version of `LottieBackgroundBehavior`.
+@objc
+public enum CompatibleBackgroundBehavior: Int {
+  /// Stop the animation and reset it to the beginning of its current play time. The completion block is called.
+  case stop
+
+  /// Pause the animation in its current state. The completion block is called.
+  case pause
+
+  /// Pause the animation and restart it when the application moves to the foreground.
+  /// The completion block is stored and called when the animation completes.
+  ///  - This is the default when using the Main Thread rendering engine.
+  case pauseAndRestore
+
+  /// Stops the animation and sets it to the end of its current play time. The completion block is called.
+  case forceFinish
+
+  /// The animation continues playing in the background.
+  ///  - This is the default when using the Core Animation rendering engine.
+  ///    Playing an animation using the Core Animation engine doesn't come with any CPU overhead,
+  ///    so using `.continuePlaying` avoids the need to stop and then resume the animation
+  ///    (which does come with some CPU overhead).
+  ///  - This mode should not be used with the Main Thread rendering engine.
+  case continuePlaying
+}
+
 /// An Objective-C compatible wrapper around Lottie's LottieAnimationView.
 @objc
 public final class CompatibleAnimationView: UIView {
@@ -187,6 +213,13 @@ public final class CompatibleAnimationView: UIView {
     }
   }
 
+  @objc
+  public var compatibleDictionaryTextProvider: CompatibleDictionaryTextProvider? {
+    didSet {
+      animationView.textProvider = compatibleDictionaryTextProvider?.textProvider ?? DefaultTextProvider()
+    }
+  }
+
   @objc
   public override var contentMode: UIView.ContentMode {
     set { animationView.contentMode = newValue }
@@ -249,6 +282,38 @@ public final class CompatibleAnimationView: UIView {
     animationView.isAnimationPlaying
   }
 
+  @objc
+  public var backgroundMode: CompatibleBackgroundBehavior {
+    get {
+      switch animationView.backgroundBehavior {
+      case .stop:
+        return .stop
+      case .pause:
+        return .pause
+      case .pauseAndRestore:
+        return .pauseAndRestore
+      case .forceFinish:
+        return .forceFinish
+      case .continuePlaying:
+        return .continuePlaying
+      }
+    }
+    set {
+      switch newValue {
+      case .stop:
+        animationView.backgroundBehavior = .stop
+      case .pause:
+        animationView.backgroundBehavior = .pause
+      case .pauseAndRestore:
+        animationView.backgroundBehavior = .pauseAndRestore
+      case .forceFinish:
+        animationView.backgroundBehavior = .forceFinish
+      case .continuePlaying:
+        animationView.backgroundBehavior = .continuePlaying
+      }
+    }
+  }
+
   @objc
   public func play() {
     play(completion: nil)
@@ -451,4 +516,29 @@ public final class CompatibleAnimationView: UIView {
     animationView.bottomAnchor.constraint(equalTo: bottomAnchor).isActive = true
   }
 }
+
+/// An Objective-C compatible wrapper around Lottie's DictionaryTextProvider.
+/// Use in tandem with CompatibleAnimationView to supply text to LottieAnimationView
+/// when using Lottie in Objective-C.
+@objc
+public final class CompatibleDictionaryTextProvider: NSObject {
+
+  // MARK: Lifecycle
+
+  @objc
+  public init(values: [String: String]) {
+    self.values = values
+    super.init()
+  }
+
+  // MARK: Internal
+
+  internal var textProvider: AnimationTextProvider? {
+    DictionaryTextProvider(values)
+  }
+
+  // MARK: Private
+
+  private let values: [String: String]
+}
 #endif

package/Sources/Public/iOS/LottieAnimationViewBase.swift

@@ -11,7 +11,7 @@ import UIKit
 /// The base view for `LottieAnimationView` on iOS, tvOS, watchOS, and macCatalyst.
 ///
 /// Enables the `LottieAnimationView` implementation to be shared across platforms.
-public class LottieAnimationViewBase: UIView {
+open class LottieAnimationViewBase: UIView {
 
   // MARK: Public
 

package/Sources/Public/macOS/LottieAnimationViewBase.macOS.swift

@@ -27,7 +27,7 @@ public enum LottieContentMode: Int {
 /// The base view for `LottieAnimationView` on macOs.
 ///
 /// Enables the `LottieAnimationView` implementation to be shared across platforms.
-public class LottieAnimationViewBase: NSView {
+open class LottieAnimationViewBase: NSView {
 
   // MARK: Public
 

package/lottie-ios.podspec

@@ -8,7 +8,7 @@
 
 Pod::Spec.new do |s|
   s.name             = 'lottie-ios'
-  s.version          = '4.1.2'
+  s.version          = '4.2.0'
   s.summary          = 'A library to render native animations from bodymovin json'
 
   s.description = <<-DESC

package/package.json

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

package/LottieAnimation/LottieAnimation.xcodeproj/xcuserdata/calstephens.xcuserdatad/xcschemes/xcschememanagement.plist

@@ -1,14 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-	<key>SchemeUserState</key>
-	<dict>
-		<key>LottieAnimation.xcscheme_^#shared#^_</key>
-		<dict>
-			<key>orderHint</key>
-			<integer>6</integer>
-		</dict>
-	</dict>
-</dict>
-</plist>

package/LottieAnimation/LottieAnimation.xcodeproj/xcuserdata/valentinperignon.xcuserdatad/xcdebugger/Breakpoints_v2.xcbkptlist

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<Bucket
-   uuid = "C335EAC3-CB4B-41DF-9652-0EB8DE739C92"
-   type = "1"
-   version = "2.0">
-</Bucket>

package/LottieAnimation/LottieAnimation.xcodeproj/xcuserdata/valentinperignon.xcuserdatad/xcschemes/xcschememanagement.plist

@@ -1,14 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-	<key>SchemeUserState</key>
-	<dict>
-		<key>LottieAnimation.xcscheme_^#shared#^_</key>
-		<dict>
-			<key>orderHint</key>
-			<integer>0</integer>
-		</dict>
-	</dict>
-</dict>
-</plist>

package/Sources/Private/Model/DotLottie/Zip/Data+Compression.swift

@@ -1,134 +0,0 @@
-//
-//  Data+Compression.swift
-//  ZIPFoundation
-//
-//  Copyright © 2017-2021 Thomas Zoechling, https://www.peakstep.com and the ZIP Foundation project authors.
-//  Released under the MIT License.
-//
-//  See https://github.com/weichsel/ZIPFoundation/blob/master/LICENSE for license information.
-//
-
-import Foundation
-
-#if canImport(zlib)
-import zlib
-#endif
-
-/// A custom handler that consumes a `Data` object containing partial entry data.
-/// - Parameters:
-///   - data: A chunk of `Data` to consume.
-/// - Throws: Can throw to indicate errors during data consumption.
-typealias ZipDataCallback = (_ data: Data) throws -> Void
-/// A custom handler that receives a position and a size that can be used to provide data from an arbitrary source.
-/// - Parameters:
-///   - position: The current read position.
-///   - size: The size of the chunk to provide.
-/// - Returns: A chunk of `Data`.
-/// - Throws: Can throw to indicate errors in the data source.
-typealias ZipDataProvider = (_ position: Int64, _ size: Int) throws -> Data
-
-extension Data {
-  enum CompressionError: Error {
-    case invalidStream
-    case corruptedData
-  }
-
-  /// Decompress the output of `provider` and pass it to `consumer`.
-  /// - Parameters:
-  ///   - size: The compressed size of the data to be decompressed.
-  ///   - bufferSize: The maximum size of the decompression buffer.
-  ///   - provider: A closure that accepts a position and a chunk size. Returns a `Data` chunk.
-  ///   - consumer: A closure that processes the result of the decompress operation.
-  /// - Returns: The checksum of the processed content.
-  static func decompress(size: Int64, bufferSize: Int, provider: ZipDataProvider, consumer: ZipDataCallback) throws -> UInt32 {
-    try process(
-      operation: COMPRESSION_STREAM_DECODE,
-      size: size,
-      bufferSize: bufferSize,
-      provider: provider,
-      consumer: consumer)
-  }
-
-  /// Calculate the `CRC32` checksum of the receiver.
-  ///
-  /// - Parameter checksum: The starting seed.
-  /// - Returns: The checksum calculated from the bytes of the receiver and the starting seed.
-  func crc32(checksum: UInt32) -> UInt32 {
-    #if canImport(zlib)
-    return withUnsafeBytes { bufferPointer in
-      let length = UInt32(count)
-      return UInt32(zlib.crc32(UInt(checksum), bufferPointer.bindMemory(to: UInt8.self).baseAddress, length))
-    }
-    #else
-    return builtInCRC32(checksum: checksum)
-    #endif
-  }
-
-}
-
-import Compression
-
-extension Data {
-  static func process(
-    operation: compression_stream_operation,
-    size: Int64,
-    bufferSize: Int,
-    provider: ZipDataProvider,
-    consumer: ZipDataCallback)
-    throws -> UInt32
-  {
-    var crc32 = UInt32(0)
-    let destPointer = UnsafeMutablePointer<UInt8>.allocate(capacity: bufferSize)
-    defer { destPointer.deallocate() }
-    let streamPointer = UnsafeMutablePointer<compression_stream>.allocate(capacity: 1)
-    defer { streamPointer.deallocate() }
-    var stream = streamPointer.pointee
-    var status = compression_stream_init(&stream, operation, COMPRESSION_ZLIB)
-    guard status != COMPRESSION_STATUS_ERROR else { throw CompressionError.invalidStream }
-    defer { compression_stream_destroy(&stream) }
-    stream.src_size = 0
-    stream.dst_ptr = destPointer
-    stream.dst_size = bufferSize
-    var position: Int64 = 0
-    var sourceData: Data?
-    repeat {
-      let isExhausted = stream.src_size == 0
-      if isExhausted {
-        do {
-          sourceData = try provider(position, Int(Swift.min(size - position, Int64(bufferSize))))
-          position += Int64(stream.prepare(for: sourceData))
-        } catch { throw error }
-      }
-      if let sourceData = sourceData {
-        sourceData.withUnsafeBytes { rawBufferPointer in
-          if let baseAddress = rawBufferPointer.baseAddress {
-            let pointer = baseAddress.assumingMemoryBound(to: UInt8.self)
-            stream.src_ptr = pointer.advanced(by: sourceData.count - stream.src_size)
-            let flags = sourceData.count < bufferSize ? Int32(COMPRESSION_STREAM_FINALIZE.rawValue) : 0
-            status = compression_stream_process(&stream, flags)
-          }
-        }
-        if operation == COMPRESSION_STREAM_ENCODE, isExhausted { crc32 = sourceData.crc32(checksum: crc32) }
-      }
-      switch status {
-      case COMPRESSION_STATUS_OK, COMPRESSION_STATUS_END:
-        let outputData = Data(bytesNoCopy: destPointer, count: bufferSize - stream.dst_size, deallocator: .none)
-        try consumer(outputData)
-        if operation == COMPRESSION_STREAM_DECODE { crc32 = outputData.crc32(checksum: crc32) }
-        stream.dst_ptr = destPointer
-        stream.dst_size = bufferSize
-      default: throw CompressionError.corruptedData
-      }
-    } while status == COMPRESSION_STATUS_OK
-    return crc32
-  }
-}
-
-extension compression_stream {
-  fileprivate mutating func prepare(for sourceData: Data?) -> Int {
-    guard let sourceData = sourceData else { return 0 }
-
-    src_size = sourceData.count
-    return sourceData.count
-  }
-}