@amazon-devices/lottie-react-native 2.0.1758683737

package/ios/LottieReactNative/AnimationViewManagerModule.swift

@@ -0,0 +1,88 @@
+import Lottie
+
+#if os(OSX)
+import AppKit
+
+typealias View = NSView
+
+#else
+import UIKit
+
+typealias View = UIView
+
+#endif
+
+@objc(LottieAnimationView)
+class AnimationViewManagerModule: RCTViewManager {
+    override func view() -> View! {
+        return ContainerView()
+    }
+
+    @objc override func constantsToExport() -> [AnyHashable : Any]! {
+        return ["VERSION": 1]
+    }
+
+    @objc(play:fromFrame:toFrame:)
+    public func play(_ reactTag: NSNumber, startFrame: NSNumber, endFrame: NSNumber) {
+        self.bridge.uiManager.addUIBlock { (uiManager, viewRegistry) in
+            guard let view = viewRegistry?[reactTag] as? ContainerView else {
+                if (RCT_DEBUG == 1) {
+                    print("Invalid view returned from registry, expecting ContainerView")
+                }
+                return
+            }
+
+            if (startFrame.intValue != -1 && endFrame.intValue != -1) {
+                view.play(fromFrame: AnimationFrameTime(truncating: startFrame), toFrame: AnimationFrameTime(truncating: endFrame))
+            } else {
+                view.play()
+            }
+        }
+    }
+
+    @objc(reset:)
+    public func reset(_ reactTag: NSNumber) {
+        self.bridge.uiManager.addUIBlock { uiManager, viewRegistry in
+            guard let view = viewRegistry?[reactTag] as? ContainerView else {
+                if (RCT_DEBUG == 1) {
+                    print("Invalid view returned from registry, expecting ContainerView")
+                }
+                return
+            }
+
+            view.reset()
+        }
+    }
+
+    @objc(pause:)
+    public func pause(_ reactTag: NSNumber) {
+        self.bridge.uiManager.addUIBlock { uiManager, viewRegistry in
+            guard let view = viewRegistry?[reactTag] as? ContainerView else {
+                if (RCT_DEBUG == 1) {
+                    print("Invalid view returned from registry, expecting ContainerView")
+                }
+                return
+            }
+
+            view.pause()
+        }
+    }
+
+    @objc(resume:)
+    public func resume(_ reactTag: NSNumber) {
+        self.bridge.uiManager.addUIBlock { uiManager, viewRegistry in
+            guard let view = viewRegistry?[reactTag] as? ContainerView else {
+                if (RCT_DEBUG == 1) {
+                    print("Invalid view returned from registry, expecting ContainerView")
+                }
+                return
+            }
+
+            view.resume()
+        }
+    }
+
+    override static func requiresMainQueueSetup() -> Bool {
+        return true
+    }
+}

package/ios/LottieReactNative/Bridging.h

@@ -0,0 +1,4 @@
+#import <React/RCTViewManager.h>
+#import <React/RCTBridge.h>
+#import <React/RCTUIManager.h>
+#import <React/RCTView.h>

package/ios/LottieReactNative/ContainerView.swift

@@ -0,0 +1,281 @@
+import Lottie
+import Foundation
+
+@objc protocol LottieContainerViewDelegate {
+    func onAnimationFinish(isCancelled: Bool);
+}
+
+@objc(LottieContainerView)
+class ContainerView: RCTView {
+    private var speed: CGFloat = 0.0
+    private var progress: CGFloat = 0.0
+    private var loop: LottieLoopMode = .playOnce
+    private var sourceJson: String = ""
+    private var resizeMode: String = ""
+    private var sourceName: String = ""
+    private var colorFilters: [NSDictionary] = []
+    private var textFilters: [NSDictionary] = []
+    private var renderMode: RenderingEngineOption = .automatic
+    @objc weak var delegate: LottieContainerViewDelegate? = nil
+
+    @objc var onAnimationFinish: RCTBubblingEventBlock?
+    var animationView: LottieAnimationView?
+    
+    override func traitCollectionDidChange(_ previousTraitCollection: UITraitCollection?) {
+        super.traitCollectionDidChange(previousTraitCollection)
+        if #available(iOS 13.0, tvOS 13.0, *) {
+            if (self.traitCollection.hasDifferentColorAppearance(comparedTo: previousTraitCollection)) {
+                applyProperties()
+                print("dark mode changed")
+            }
+        }
+    }
+
+    @objc func setSpeed(_ newSpeed: CGFloat) {
+        speed = newSpeed
+
+        if (newSpeed != 0.0) {
+            animationView?.animationSpeed = newSpeed
+            if (!(animationView?.isAnimationPlaying ?? true)) {
+                animationView?.play()
+            }
+        } else if (animationView?.isAnimationPlaying ?? false) {
+            animationView?.pause()
+        }
+    }
+
+    @objc func setProgress(_ newProgress: CGFloat) {
+        progress = newProgress
+        animationView?.currentProgress = progress
+    }
+
+    override func reactSetFrame(_ frame: CGRect) {
+        super.reactSetFrame(frame)
+        animationView?.reactSetFrame(frame)
+    }
+
+    @objc func setLoop(_ isLooping: Bool) {
+        loop = isLooping ? .loop : .playOnce
+        animationView?.loopMode = loop
+    }
+    
+    @objc func setTextFiltersIOS(_ newTextFilters: [NSDictionary]) {
+        textFilters = newTextFilters
+        
+        if (textFilters.count > 0) {
+            var filters = [String:String]()
+            for filter in textFilters {
+                let key = filter.value(forKey: "keypath") as! String
+                let value = filter.value(forKey: "text") as! String
+                filters[key] = value;
+            }
+            
+            let starAnimationView = LottieAnimationView()
+            starAnimationView.textProvider = DictionaryTextProvider(filters)
+            starAnimationView.animation = animationView?.animation
+            replaceAnimationView(next: starAnimationView)
+        }
+    }
+
+    func getLottieConfiguration() -> LottieConfiguration {
+        return LottieConfiguration(
+            renderingEngine: renderMode
+        )
+    }
+       
+    @objc func setRenderMode(_ newRenderMode: String) {
+        switch newRenderMode {
+        case "SOFTWARE":
+            if (renderMode == .mainThread) {
+                return
+            }
+            renderMode = .mainThread
+        case "HARDWARE":
+            if (renderMode == .coreAnimation) {
+                return
+            }
+            renderMode = .coreAnimation
+        case "AUTOMATIC":
+            fallthrough
+        default:
+            if (renderMode == .automatic) {
+                return
+            }
+            renderMode = .automatic
+        }
+        if (animationView != nil) {
+            let starAnimationView = LottieAnimationView(
+                animation: animationView?.animation,
+                configuration: getLottieConfiguration()
+            )
+            replaceAnimationView(next: starAnimationView)
+        }
+    }
+
+    @objc func setSourceURL(_ newSourceURLString: String) {
+        var url = URL(string: newSourceURLString)
+        
+        if(url?.scheme == nil) {
+            // interpret raw URL paths as relative to the resource bundle
+            url = URL(fileURLWithPath: newSourceURLString, relativeTo: Bundle.main.resourceURL)
+        }
+    
+        if(url != nil) {
+            DispatchQueue.global(qos: .default).async {
+                do {
+                    let sourceJson = try String(contentsOf: url!)
+                    guard let data = sourceJson.data(using: String.Encoding.utf8),
+                    let animation = try? JSONDecoder().decode(LottieAnimation.self, from: data) else {
+                        if (RCT_DEBUG == 1) {
+                            print("Unable to decode the lottie animation object from the fetched URL source")
+                        }
+                        return
+                    }
+
+                    DispatchQueue.main.async {
+                        let starAnimationView = LottieAnimationView(
+                            animation: animation,
+                            configuration: self.getLottieConfiguration()
+                        )
+                        self.replaceAnimationView(next: starAnimationView)
+                        self.animationView?.play()
+                    }
+                } catch {
+                    if (RCT_DEBUG == 1) {
+                        print("Unable to load the lottie animation URL")
+                    }
+                }
+            }
+        }
+    }
+
+    @objc func setSourceJson(_ newSourceJson: String) {
+        sourceJson = newSourceJson
+
+        guard let data = sourceJson.data(using: String.Encoding.utf8),
+        let animation = try? JSONDecoder().decode(LottieAnimation.self, from: data) else {
+            if (RCT_DEBUG == 1) {
+                print("Unable to create the lottie animation object from the JSON source")
+            }
+            return
+        }
+
+        let starAnimationView = LottieAnimationView(
+            animation: animation,
+            configuration: getLottieConfiguration()
+        )
+        replaceAnimationView(next: starAnimationView)
+    }
+
+    @objc func setSourceName(_ newSourceName: String) {
+        if (newSourceName == sourceName) {
+          return
+        }
+        sourceName = newSourceName
+
+        let starAnimationView = LottieAnimationView(
+            name: sourceName,
+            configuration: getLottieConfiguration()
+        )
+        replaceAnimationView(next: starAnimationView)
+    }
+
+    @objc func setResizeMode(_ resizeMode: String) {
+        switch (resizeMode) {
+        case "cover":
+            animationView?.contentMode = .scaleAspectFill
+        case "contain":
+            animationView?.contentMode = .scaleAspectFit
+        case "center":
+            animationView?.contentMode = .center
+        default: break
+        }
+    }
+
+    @objc func setColorFilters(_ newColorFilters: [NSDictionary]) {
+        colorFilters = newColorFilters
+        applyProperties()
+    }
+
+    // There is no Nullable CGFloat in Objective-C, so this function uses a Nullable NSNumber and converts it later
+    @objc(playFromFrame:toFrame:)
+    func objcCompatiblePlay(fromFrame: NSNumber? = nil, toFrame: AnimationFrameTime) {
+        let convertedFromFrame = fromFrame != nil ? CGFloat(truncating: fromFrame!) : nil;
+        play(fromFrame: convertedFromFrame, toFrame: toFrame);
+    }
+    
+    func play(fromFrame: AnimationFrameTime? = nil, toFrame: AnimationFrameTime) {
+        let callback: LottieCompletionBlock = { animationFinished in
+            if let onFinish = self.onAnimationFinish {
+                onFinish(["isCancelled": !animationFinished])
+            }
+            self.delegate?.onAnimationFinish(isCancelled: !animationFinished);
+        }
+
+        animationView?.backgroundBehavior = .pauseAndRestore
+        animationView?.play(fromFrame: fromFrame, toFrame: toFrame, loopMode: self.loop, completion: callback);
+    }
+
+    @objc func play() {
+        let callback: LottieCompletionBlock = { animationFinished in
+            if let onFinish = self.onAnimationFinish {
+                onFinish(["isCancelled": !animationFinished])
+            }
+            self.delegate?.onAnimationFinish(isCancelled: !animationFinished);
+        }
+
+        animationView?.backgroundBehavior = .pauseAndRestore
+        animationView?.play(completion: callback)
+    }
+
+    @objc func reset() {
+        animationView?.currentProgress = 0;
+        animationView?.pause()
+    }
+
+    @objc func pause() {
+        animationView?.pause()
+    }
+
+    @objc func resume() {
+        play()
+    }
+
+    // reset the animationView frame whenever the view's frame changes
+    override var frame: CGRect {
+        didSet {
+            animationView?.reactSetFrame(frame)
+        }
+    }
+    
+    // MARK: Private
+    func replaceAnimationView(next: LottieAnimationView) {
+        animationView?.removeFromSuperview()
+
+        let contentMode = animationView?.contentMode ?? .scaleAspectFit
+        animationView = next
+        addSubview(next)
+        animationView?.contentMode = contentMode
+        animationView?.reactSetFrame(frame)
+        applyProperties()
+    }
+
+    func applyProperties() {
+        guard let animationView = animationView else { return }
+        let isPlaying = animationView.isAnimationPlaying
+        animationView.currentProgress = progress
+        animationView.animationSpeed = speed
+        animationView.loopMode = loop
+        if (colorFilters.count > 0) {
+            for filter in colorFilters {
+                let keypath: String = "\(filter.value(forKey: "keypath") as! String).**.Color"
+                let fillKeypath = AnimationKeypath(keypath: keypath)
+                let colorFilterValueProvider = ColorValueProvider((filter.value(forKey: "color") as! PlatformColor).lottieColorValue)
+                animationView.setValueProvider(colorFilterValueProvider, keypath: fillKeypath)
+            }
+        }
+        if isPlaying {
+           resume()
+        }
+    }
+}

package/ios/LottieReactNative/LRNAnimationViewManagerObjC.m

@@ -0,0 +1,25 @@
+#import <React/RCTViewManager.h>
+#import "RCTConvert+Lottie.h"
+
+@interface RCT_EXTERN_MODULE(LottieAnimationView, RCTViewManager)
+
+RCT_EXPORT_VIEW_PROPERTY(resizeMode, NSString);
+RCT_EXPORT_VIEW_PROPERTY(sourceJson, NSString);
+RCT_EXPORT_VIEW_PROPERTY(sourceName, NSString);
+RCT_EXPORT_VIEW_PROPERTY(sourceURL, NSString);
+RCT_EXPORT_VIEW_PROPERTY(progress, CGFloat);
+RCT_EXPORT_VIEW_PROPERTY(loop, BOOL);
+RCT_EXPORT_VIEW_PROPERTY(speed, CGFloat);
+RCT_EXPORT_VIEW_PROPERTY(onAnimationFinish, RCTBubblingEventBlock);
+RCT_EXPORT_VIEW_PROPERTY(colorFilters, LRNColorFilters);
+RCT_EXPORT_VIEW_PROPERTY(textFiltersIOS, NSArray);
+RCT_EXPORT_VIEW_PROPERTY(renderMode, NSString);
+
+RCT_EXTERN_METHOD(play:(nonnull NSNumber *)reactTag fromFrame:(nonnull NSNumber *) startFrame toFrame:(nonnull NSNumber *) endFrame);
+
+RCT_EXTERN_METHOD(reset:(nonnull NSNumber *)reactTag);
+RCT_EXTERN_METHOD(pause:(nonnull NSNumber *)reactTag);
+RCT_EXTERN_METHOD(resume:(nonnull NSNumber *)reactTag);
+
+@end
+

package/ios/LottieReactNative/PlatformColor.swift

@@ -0,0 +1,31 @@
+//
+//  PlatformColor.swift
+//  LottieReactNative
+//
+//  Created by Igor Mandrigin on 2020-08-28.
+//  Copyright © 2020 Airbnb. All rights reserved.
+//
+import Lottie
+
+#if os(OSX)
+
+import AppKit
+
+typealias PlatformColor = NSColor
+
+// NSColor doesn't have this extension (UIColor receives it from Lottie), so we add it here
+public extension NSColor {
+    var lottieColorValue: Color {
+        var r: CGFloat = 0, g: CGFloat = 0, b: CGFloat = 0, a: CGFloat = 0
+        getRed(&r, green: &g, blue: &b, alpha: &a)
+        return Color(r: Double(r), g: Double(g), b: Double(b), a: Double(a))
+    }
+}
+
+#else
+
+import UIKit
+
+typealias PlatformColor = UIColor
+
+#endif

package/ios/LottieReactNative/RCTConvert+Lottie.h

@@ -0,0 +1,7 @@
+#import <React/RCTConvert.h>
+
+@interface RCTConvert (Lottie)
+
++ (NSArray<NSDictionary *> *)LRNColorFilters:(id)json;
+
+@end

package/ios/LottieReactNative/RCTConvert+Lottie.m

@@ -0,0 +1,24 @@
+#import "RCTConvert+Lottie.h"
+
+@implementation RCTConvert (Lottie)
+
++ (NSArray<NSDictionary *> *)LRNColorFilters:(id)json
+{
+  NSArray *rawFilters = [self NSArray:json];
+  NSMutableArray *filters = [NSMutableArray arrayWithCapacity:[rawFilters count]];
+  [rawFilters enumerateObjectsUsingBlock:^(NSDictionary *rawFilter, NSUInteger idx, BOOL *stop) {
+    NSString *keypath = rawFilter[@"keypath"];
+    #if TARGET_OS_OSX
+      NSColor *color = [RCTConvert NSColor:rawFilter[@"color"]];
+    #else
+      UIColor *color = [RCTConvert UIColor:rawFilter[@"color"]];
+    #endif
+      [filters addObject:@{
+        @"color": color,
+        @"keypath": keypath,
+      }];
+  }];
+  return filters;
+}
+
+@end