lottie-ios 3.2.3 → 3.4.0

package/{lottie-swift/src/Private → Sources/Private/MainThread}/LayerContainers/CompLayers/CompositionLayer.swift

@@ -8,70 +8,37 @@
 import Foundation
 import QuartzCore
 
-/**
- The base class for a child layer of CompositionContainer
- */
+// MARK: - CompositionLayer
+
+/// The base class for a child layer of CompositionContainer
 class CompositionLayer: CALayer, KeypathSearchable {
-  
-  weak var layerDelegate: CompositionLayerDelegate?
-  
-  let transformNode: LayerTransformNode
-  
-  let contentsLayer: CALayer = CALayer()
-  
-  let maskLayer: MaskContainerLayer?
-  
-  let matteType: MatteType?
-  
-  var renderScale: CGFloat = 1 {
-    didSet {
-      self.updateRenderScale()
-    }
-  }
-  
-  var matteLayer: CompositionLayer? {
-    didSet {
-      if let matte = matteLayer {
-        if let type = matteType, type == .invert {
-          mask = InvertedMatteLayer(inputMatte: matte)
-        } else {
-          mask = matte
-        }
-      } else {
-        mask = nil
-      }
-    }
-  }
-  
-  let inFrame: CGFloat
-  let outFrame: CGFloat
-  let startFrame: CGFloat
-  let timeStretch: CGFloat
-  
+
+  // MARK: Lifecycle
+
   init(layer: LayerModel, size: CGSize) {
-    self.transformNode = LayerTransformNode(transform: layer.transform)
+    transformNode = LayerTransformNode(transform: layer.transform)
     if let masks = layer.masks {
       maskLayer = MaskContainerLayer(masks: masks)
     } else {
       maskLayer = nil
     }
-    self.matteType = layer.matte
-    self.inFrame = layer.inFrame.cgFloat
-    self.outFrame = layer.outFrame.cgFloat
-    self.timeStretch = layer.timeStretch.cgFloat
-    self.startFrame = layer.startTime.cgFloat
-    self.keypathName = layer.name
-    self.childKeypaths = [transformNode.transformProperties]
+    matteType = layer.matte
+    inFrame = layer.inFrame.cgFloat
+    outFrame = layer.outFrame.cgFloat
+    timeStretch = layer.timeStretch.cgFloat
+    startFrame = layer.startTime.cgFloat
+    keypathName = layer.name
+    childKeypaths = [transformNode.transformProperties]
     super.init()
-    self.anchorPoint = .zero
-    self.actions = [
+    anchorPoint = .zero
+    actions = [
       "opacity" : NSNull(),
       "transform" : NSNull(),
       "bounds" : NSNull(),
       "anchorPoint" : NSNull(),
-      "sublayerTransform" : NSNull()
+      "sublayerTransform" : NSNull(),
     ]
-    
+
     contentsLayer.anchorPoint = .zero
     contentsLayer.bounds = CGRect(origin: .zero, size: size)
     contentsLayer.actions = [
@@ -80,36 +47,90 @@ class CompositionLayer: CALayer, KeypathSearchable {
       "bounds" : NSNull(),
       "anchorPoint" : NSNull(),
       "sublayerTransform" : NSNull(),
-      "hidden" : NSNull()
+      "hidden" : NSNull(),
     ]
+    compositingFilter = layer.blendMode.filterName
     addSublayer(contentsLayer)
-    
+
     if let maskLayer = maskLayer {
       contentsLayer.mask = maskLayer
     }
+
+    name = layer.name
   }
-  
+
   override init(layer: Any) {
     /// Used for creating shadow model layers. Read More here: https://developer.apple.com/documentation/quartzcore/calayer/1410842-init
     guard let layer = layer as? CompositionLayer else {
       fatalError("Wrong Layer Class")
     }
-    self.transformNode = layer.transformNode
-    self.matteType = layer.matteType
-    self.inFrame = layer.inFrame
-    self.outFrame = layer.outFrame
-    self.timeStretch = layer.timeStretch
-    self.startFrame = layer.startFrame
-    self.keypathName = layer.keypathName
-    self.childKeypaths = [transformNode.transformProperties]
-    self.maskLayer = nil
+    transformNode = layer.transformNode
+    matteType = layer.matteType
+    inFrame = layer.inFrame
+    outFrame = layer.outFrame
+    timeStretch = layer.timeStretch
+    startFrame = layer.startFrame
+    keypathName = layer.keypathName
+    childKeypaths = [transformNode.transformProperties]
+    maskLayer = nil
     super.init(layer: layer)
   }
-  
-  required init?(coder aDecoder: NSCoder) {
+
+  required init?(coder _: NSCoder) {
     fatalError("init(coder:) has not been implemented")
   }
-  
+
+  // MARK: Internal
+
+  weak var layerDelegate: CompositionLayerDelegate?
+
+  let transformNode: LayerTransformNode
+
+  let contentsLayer = CALayer()
+
+  let maskLayer: MaskContainerLayer?
+
+  let matteType: MatteType?
+
+  let inFrame: CGFloat
+  let outFrame: CGFloat
+  let startFrame: CGFloat
+  let timeStretch: CGFloat
+
+  // MARK: Keypath Searchable
+
+  let keypathName: String
+
+  final var childKeypaths: [KeypathSearchable]
+
+  var renderScale: CGFloat = 1 {
+    didSet {
+      updateRenderScale()
+    }
+  }
+
+  var matteLayer: CompositionLayer? {
+    didSet {
+      if let matte = matteLayer {
+        if let type = matteType, type == .invert {
+          mask = InvertedMatteLayer(inputMatte: matte)
+        } else {
+          mask = matte
+        }
+      } else {
+        mask = nil
+      }
+    }
+  }
+
+  var keypathProperties: [String: AnyNodeProperty] {
+    [:]
+  }
+
+  var keypathLayer: CALayer? {
+    contentsLayer
+  }
+
   final func displayWithFrame(frame: CGFloat, forceUpdates: Bool) {
     transformNode.updateTree(frame, forceUpdates: forceUpdates)
     let layerVisible = frame.isInRangeOrEqual(inFrame, outFrame)
@@ -123,31 +144,18 @@ class CompositionLayer: CALayer, KeypathSearchable {
     contentsLayer.isHidden = !layerVisible
     layerDelegate?.frameUpdated(frame: frame)
   }
-  
-  func displayContentsWithFrame(frame: CGFloat, forceUpdates: Bool) {
+
+  func displayContentsWithFrame(frame _: CGFloat, forceUpdates _: Bool) {
     /// To be overridden by subclass
   }
-  
-  // MARK: Keypath Searchable
-  
-  let keypathName: String
-  
-  var keypathProperties: [String : AnyNodeProperty] {
-    return [:]
-  }
-  
-  final var childKeypaths: [KeypathSearchable]
-  
-  var keypathLayer: CALayer? {
-    return contentsLayer
-  }
-  
+
   func updateRenderScale() {
-    /// To be overridden by subclass
+    contentsScale = renderScale
   }
 }
 
+// MARK: - CompositionLayerDelegate
+
 protocol CompositionLayerDelegate: AnyObject {
   func frameUpdated(frame: CGFloat)
 }
-

package/{lottie-swift/src/Private → Sources/Private/MainThread}/LayerContainers/CompLayers/ImageCompositionLayer.swift

@@ -5,43 +5,46 @@
 //  Created by Brandon Withrow on 1/25/19.
 //
 
-import Foundation
 import CoreGraphics
+import Foundation
 import QuartzCore
 
 final class ImageCompositionLayer: CompositionLayer {
-  
-  var image: CGImage? = nil {
-    didSet {
-      if let image = image {
-        contentsLayer.contents = image
-      } else {
-        contentsLayer.contents = nil
-      }
-    }
-  }
-  
-  let imageReferenceID: String
-  
+
+  // MARK: Lifecycle
+
   init(imageLayer: ImageLayerModel, size: CGSize) {
-    self.imageReferenceID = imageLayer.referenceID
+    imageReferenceID = imageLayer.referenceID
     super.init(layer: imageLayer, size: size)
     contentsLayer.masksToBounds = true
     contentsLayer.contentsGravity = CALayerContentsGravity.resize
   }
-  
+
   override init(layer: Any) {
     /// Used for creating shadow model layers. Read More here: https://developer.apple.com/documentation/quartzcore/calayer/1410842-init
     guard let layer = layer as? ImageCompositionLayer else {
       fatalError("init(layer:) Wrong Layer Class")
     }
-    self.imageReferenceID = layer.imageReferenceID
-    self.image = nil
+    imageReferenceID = layer.imageReferenceID
+    image = nil
     super.init(layer: layer)
   }
-  
-  required init?(coder aDecoder: NSCoder) {
+
+  required init?(coder _: NSCoder) {
     fatalError("init(coder:) has not been implemented")
   }
-  
+
+  // MARK: Internal
+
+  let imageReferenceID: String
+
+  var image: CGImage? = nil {
+    didSet {
+      if let image = image {
+        contentsLayer.contents = image
+      } else {
+        contentsLayer.contents = nil
+      }
+    }
+  }
 }

package/{lottie-swift/src/Private → Sources/Private/MainThread}/LayerContainers/CompLayers/MaskContainerLayer.swift

@@ -29,13 +29,17 @@ extension MaskMode {
   }
 }
 
+// MARK: - MaskContainerLayer
+
 final class MaskContainerLayer: CALayer {
-  
+
+  // MARK: Lifecycle
+
   init(masks: [Mask]) {
     super.init()
     anchorPoint = .zero
     var containerLayer = CALayer()
-    var firstObject: Bool = true
+    var firstObject = true
     for mask in masks {
       let maskLayer = MaskLayer(mask: mask)
       maskLayers.append(maskLayer)
@@ -53,7 +57,7 @@ final class MaskContainerLayer: CALayer {
     }
     addSublayer(containerLayer)
   }
-  
+
   override init(layer: Any) {
     /// Used for creating shadow model layers. Read More here: https://developer.apple.com/documentation/quartzcore/calayer/1410842-init
     guard let layer = layer as? MaskContainerLayer else {
@@ -61,71 +65,85 @@ final class MaskContainerLayer: CALayer {
     }
     super.init(layer: layer)
   }
-  
-  fileprivate var maskLayers: [MaskLayer] = []
-  
+
+  required init?(coder _: NSCoder) {
+    fatalError("init(coder:) has not been implemented")
+  }
+
+  // MARK: Internal
+
   func updateWithFrame(frame: CGFloat, forceUpdates: Bool) {
     maskLayers.forEach({ $0.updateWithFrame(frame: frame, forceUpdates: forceUpdates) })
   }
-  
-  required init?(coder aDecoder: NSCoder) {
-    fatalError("init(coder:) has not been implemented")
-  }
+
+  // MARK: Fileprivate
+
+  fileprivate var maskLayers: [MaskLayer] = []
 }
 
 extension CGRect {
   static var veryLargeRect: CGRect {
-    return CGRect(x: -100_000_000,
-                  y: -100_000_000,
-                  width: 200_000_000,
-                  height: 200_000_000)
+    CGRect(
+      x: -100_000_000,
+      y: -100_000_000,
+      width: 200_000_000,
+      height: 200_000_000)
   }
 }
 
-fileprivate class MaskLayer: CALayer {
-  
-  let properties: MaskNodeProperties?
-  
-  let maskLayer = CAShapeLayer()
-  
+// MARK: - MaskLayer
+
+private class MaskLayer: CALayer {
+
+  // MARK: Lifecycle
+
   init(mask: Mask) {
-    self.properties = MaskNodeProperties(mask: mask)
+    properties = MaskNodeProperties(mask: mask)
     super.init()
     addSublayer(maskLayer)
     anchorPoint = .zero
-    maskLayer.fillColor = mask.mode == .add ? CGColor(colorSpace: CGColorSpaceCreateDeviceRGB(), components: [1, 0, 0, 1]) :
-      CGColor(colorSpace: CGColorSpaceCreateDeviceRGB(), components: [0, 1, 0, 1])
+    maskLayer.fillColor = mask.mode == .add
+      ? CGColor(colorSpace: CGColorSpaceCreateDeviceRGB(), components: [1, 0, 0, 1])
+      : CGColor(colorSpace: CGColorSpaceCreateDeviceRGB(), components: [0, 1, 0, 1])
     maskLayer.fillRule = CAShapeLayerFillRule.evenOdd
-    self.actions = [
-      "opacity" : NSNull()
+    actions = [
+      "opacity" : NSNull(),
     ]
-    
+
   }
-  
+
   override init(layer: Any) {
-    self.properties = nil
+    properties = nil
     super.init(layer: layer)
   }
-  
-  required init?(coder aDecoder: NSCoder) {
+
+  required init?(coder _: NSCoder) {
     fatalError("init(coder:) has not been implemented")
   }
-  
+
+  // MARK: Internal
+
+  let properties: MaskNodeProperties?
+
+  let maskLayer = CAShapeLayer()
+
   func updateWithFrame(frame: CGFloat, forceUpdates: Bool) {
     guard let properties = properties else { return }
     if properties.opacity.needsUpdate(frame: frame) || forceUpdates {
       properties.opacity.update(frame: frame)
-      self.opacity = Float(properties.opacity.value.cgFloatValue)
+      opacity = Float(properties.opacity.value.cgFloatValue)
     }
-    
+
     if properties.shape.needsUpdate(frame: frame) || forceUpdates {
       properties.shape.update(frame: frame)
       properties.expansion.update(frame: frame)
-      
+
       let shapePath = properties.shape.value.cgPath()
       var path = shapePath
-      if properties.mode.usableMode == .subtract && !properties.inverted ||
-        (properties.mode.usableMode == .add && properties.inverted) {
+      if
+        properties.mode.usableMode == .subtract && !properties.inverted ||
+        (properties.mode.usableMode == .add && properties.inverted)
+      {
         /// Add a bounds rect to invert the mask
         let newPath = CGMutablePath()
         newPath.addRect(CGRect.veryLargeRect)
@@ -134,35 +152,40 @@ fileprivate class MaskLayer: CALayer {
       }
       maskLayer.path = path
     }
-    
+
   }
 }
 
-fileprivate class MaskNodeProperties: NodePropertyMap {
-  
-  var propertyMap: [String : AnyNodeProperty]
-  
-  var properties: [AnyNodeProperty]
-  
+// MARK: - MaskNodeProperties
+
+private class MaskNodeProperties: NodePropertyMap {
+
+  // MARK: Lifecycle
+
   init(mask: Mask) {
-    self.mode = mask.mode
-    self.inverted = mask.inverted
-    self.opacity = NodeProperty(provider: KeyframeInterpolator(keyframes: mask.opacity.keyframes))
-    self.shape = NodeProperty(provider: KeyframeInterpolator(keyframes: mask.shape.keyframes))
-    self.expansion = NodeProperty(provider: KeyframeInterpolator(keyframes: mask.expansion.keyframes))
-    self.propertyMap = [
+    mode = mask.mode
+    inverted = mask.inverted
+    opacity = NodeProperty(provider: KeyframeInterpolator(keyframes: mask.opacity.keyframes))
+    shape = NodeProperty(provider: KeyframeInterpolator(keyframes: mask.shape.keyframes))
+    expansion = NodeProperty(provider: KeyframeInterpolator(keyframes: mask.expansion.keyframes))
+    propertyMap = [
       "Opacity" : opacity,
       "Shape" : shape,
-      "Expansion" : expansion
+      "Expansion" : expansion,
     ]
-    self.properties = Array(self.propertyMap.values)
+    properties = Array(propertyMap.values)
   }
-  
+
+  // MARK: Internal
+
+  var propertyMap: [String: AnyNodeProperty]
+
+  var properties: [AnyNodeProperty]
+
   let mode: MaskMode
   let inverted: Bool
-  
+
   let opacity: NodeProperty<Vector1D>
   let shape: NodeProperty<BezierPath>
   let expansion: NodeProperty<Vector1D>
 }
-

package/{lottie-swift/src/Private → Sources/Private/MainThread}/LayerContainers/CompLayers/NullCompositionLayer.swift

@@ -8,15 +8,15 @@
 import Foundation
 
 final class NullCompositionLayer: CompositionLayer {
-  
+
   init(layer: LayerModel) {
     super.init(layer: layer, size: .zero)
   }
-  
-  required init?(coder aDecoder: NSCoder) {
+
+  required init?(coder _: NSCoder) {
     fatalError("init(coder:) has not been implemented")
   }
-  
+
   override init(layer: Any) {
     /// Used for creating shadow model layers. Read More here: https://developer.apple.com/documentation/quartzcore/calayer/1410842-init
     guard let layer = layer as? NullCompositionLayer else {
@@ -24,5 +24,5 @@ final class NullCompositionLayer: CompositionLayer {
     }
     super.init(layer: layer)
   }
-  
+
 }

package/{lottie-swift/src/Private → Sources/Private/MainThread}/LayerContainers/CompLayers/PreCompositionLayer.swift

@@ -9,36 +9,41 @@ import Foundation
 import QuartzCore
 
 final class PreCompositionLayer: CompositionLayer {
-  
-  let frameRate: CGFloat
-  let remappingNode: NodeProperty<Vector1D>?
-  fileprivate var animationLayers: [CompositionLayer]
-  
-  init(precomp: PreCompLayerModel,
-       asset: PrecompAsset,
-       layerImageProvider: LayerImageProvider,
-       textProvider: AnimationTextProvider,
-       fontProvider: AnimationFontProvider,
-       assetLibrary: AssetLibrary?,
-       frameRate: CGFloat) {
-    self.animationLayers = []
+
+  // MARK: Lifecycle
+
+  init(
+    precomp: PreCompLayerModel,
+    asset: PrecompAsset,
+    layerImageProvider: LayerImageProvider,
+    textProvider: AnimationTextProvider,
+    fontProvider: AnimationFontProvider,
+    assetLibrary: AssetLibrary?,
+    frameRate: CGFloat)
+  {
+    animationLayers = []
     if let keyframes = precomp.timeRemapping?.keyframes {
-      self.remappingNode = NodeProperty(provider: KeyframeInterpolator(keyframes: keyframes))
+      remappingNode = NodeProperty(provider: KeyframeInterpolator(keyframes: keyframes))
     } else {
-      self.remappingNode = nil
+      remappingNode = nil
     }
     self.frameRate = frameRate
     super.init(layer: precomp, size: CGSize(width: precomp.width, height: precomp.height))
     bounds = CGRect(origin: .zero, size: CGSize(width: precomp.width, height: precomp.height))
     contentsLayer.masksToBounds = true
     contentsLayer.bounds = bounds
-    
-    let layers = asset.layers.initializeCompositionLayers(assetLibrary: assetLibrary, layerImageProvider: layerImageProvider, textProvider: textProvider,  fontProvider: fontProvider, frameRate: frameRate)
-    
+
+    let layers = asset.layers.initializeCompositionLayers(
+      assetLibrary: assetLibrary,
+      layerImageProvider: layerImageProvider,
+      textProvider: textProvider,
+      fontProvider: fontProvider,
+      frameRate: frameRate)
+
     var imageLayers = [ImageCompositionLayer]()
-    
+
     var mattedLayer: CompositionLayer? = nil
-    
+
     for layer in layers.reversed() {
       layer.bounds = bounds
       animationLayers.append(layer)
@@ -51,35 +56,49 @@ final class PreCompositionLayer: CompositionLayer {
         mattedLayer = nil
         continue
       }
-      if let matte = layer.matteType,
-        (matte == .add || matte == .invert) {
+      if
+        let matte = layer.matteType,
+        matte == .add || matte == .invert
+      {
         /// We have a layer that requires a matte.
         mattedLayer = layer
       }
       contentsLayer.addSublayer(layer)
     }
-    
-    self.childKeypaths.append(contentsOf: layers)
-    
+
+    childKeypaths.append(contentsOf: layers)
+
     layerImageProvider.addImageLayers(imageLayers)
   }
-  
+
   override init(layer: Any) {
     /// Used for creating shadow model layers. Read More here: https://developer.apple.com/documentation/quartzcore/calayer/1410842-init
     guard let layer = layer as? PreCompositionLayer else {
       fatalError("init(layer:) Wrong Layer Class")
     }
-    self.frameRate = layer.frameRate
-    self.remappingNode = nil
-    self.animationLayers = []
-    
+    frameRate = layer.frameRate
+    remappingNode = nil
+    animationLayers = []
+
     super.init(layer: layer)
   }
-  
-  required init?(coder aDecoder: NSCoder) {
+
+  required init?(coder _: NSCoder) {
     fatalError("init(coder:) has not been implemented")
   }
-  
+
+  // MARK: Internal
+
+  let frameRate: CGFloat
+  let remappingNode: NodeProperty<Vector1D>?
+
+  override var keypathProperties: [String: AnyNodeProperty] {
+    guard let remappingNode = remappingNode else {
+      return super.keypathProperties
+    }
+    return ["Time Remap" : remappingNode]
+  }
+
   override func displayContentsWithFrame(frame: CGFloat, forceUpdates: Bool) {
     let localFrame: CGFloat
     if let remappingNode = remappingNode {
@@ -90,16 +109,13 @@ final class PreCompositionLayer: CompositionLayer {
     }
     animationLayers.forEach( { $0.displayWithFrame(frame: localFrame, forceUpdates: forceUpdates) })
   }
-  
-  override var keypathProperties: [String : AnyNodeProperty] {
-    guard let remappingNode = remappingNode else {
-      return super.keypathProperties
-    }
-    return ["Time Remap" : remappingNode]
-  }
-  
+
   override func updateRenderScale() {
     super.updateRenderScale()
     animationLayers.forEach( { $0.renderScale = renderScale } )
   }
+
+  // MARK: Fileprivate
+
+  fileprivate var animationLayers: [CompositionLayer]
 }