Merge pull request #6 from scribd/stephane/respect_animation_flags

Update calculator to reload data if the view frame is zero/empty. Make sure to respect reloading data even when data threshold is too high.

Author: Stephane Magne

LiveCollectionsFramework/LiveCollections/Classes/Internal/ItemDataCalculator.swift

@@ -179,9 +179,9 @@ private extension ItemDataCalculator {
                 }
             }
         }
-        
-        // Short circuit if there are too many items
-        
+
+        // calculate data change
+
         let dataSetTooLarge = itemProvider.items.count > itemProvider.dataCountAnimationThreshold ||
             updatedItems.count > itemProvider.dataCountAnimationThreshold
 
@@ -194,23 +194,9 @@ private extension ItemDataCalculator {
         } else {
             (delta, deletedItems) = _calculateDelta(updatedItems, itemProvider: itemProvider)
         }
-        
+
         let deltaChangeTooLarge = delta.changeCount > itemProvider.deltaCountAnimationThreshold
-        
-        guard dataSetTooLarge == false && deltaChangeTooLarge == false else {
-            _updateSections(updatedItems,
-                            itemProvider: itemProvider,
-                            section: section,
-                            viewProvider: viewProvider,
-                            viewDelegate: viewDelegate,
-                            deletionDelegate: deletionDelegate,
-                            updateData: updateData,
-                            completion: completion)
-            return
-        }
-        
-        // Otherwise animate
-        
+
         let calculationCompletion: () -> Void = { [weak self, weak weakDeletionDelegate = deletionDelegate] in
             completion?()
             if deletedItems.isEmpty == false {
@@ -224,12 +210,7 @@ private extension ItemDataCalculator {
             calculationCompletion()
             return
         }
-        
-        let itemAnimationStlye: AnimationStyle = {
-            guard let animationDelegate = animationDelegate else { return .preciseAnimations }
-            return animationDelegate.preferredItemAnimationStyle(for: delta)
-        }()
-        
+
         DispatchQueue.main.async { [weak weakViewProvider = viewProvider] in
             guard let targetView = weakViewProvider?.view else {
                 updateData()
@@ -240,14 +221,40 @@ private extension ItemDataCalculator {
             if targetView !== view {
                 targetView.reloadData()
             }
-            
+
+            let itemAnimationStlye: AnimationStyle = {
+                if view.frame.isEmpty { return .reloadData }
+                guard let animationDelegate = animationDelegate else { return .preciseAnimations }
+                return animationDelegate.preferredItemAnimationStyle(for: delta)
+            }()
+
             switch itemAnimationStlye {
             case .reloadData:
                 updateData()
                 targetView.reloadData()
                 calculationCompletion()
-                
-            case .reloadSections:
+
+            case .reloadSections,
+                 .preciseAnimations:
+                // Short circuit if there are too many items
+                guard dataSetTooLarge == false && deltaChangeTooLarge == false else {
+                    self._updateSections(updatedItems,
+                                         itemProvider: itemProvider,
+                                         section: section,
+                                         viewProvider: viewProvider,
+                                         viewDelegate: viewDelegate,
+                                         deletionDelegate: deletionDelegate,
+                                         updateData: updateData,
+                                         completion: completion)
+                    return
+                }
+            }
+
+            // Otherwise animate
+
+            switch itemAnimationStlye {
+            case .reloadData,
+                 .reloadSections:
                 let sectionUpdate = SectionUpdate(section: section,
                                                   delta: delta,
                                                   delegate: viewDelegate,
@@ -294,41 +301,26 @@ private extension ItemDataCalculator {
                 }
             }
         }
-        
-        let calculationCompletion: () -> Void = { [weak self] in
-            completion?()
-            self?._performNextCalculation()
-        }
 
-        // Short circuit if there are too many items
+        // calculate data change
 
         let deltaChangeTooLarge = delta.changeCount > itemProvider.deltaCountAnimationThreshold
-        
-        guard deltaChangeTooLarge == false else {
-            _updateSections(section: section,
-                            viewProvider: viewProvider,
-                            viewDelegate: viewDelegate,
-                            updateData: updateData,
-                            calculationCompletion: calculationCompletion)
-            return
+
+        let calculationCompletion: () -> Void = { [weak self] in
+            completion?()
+            self?._performNextCalculation()
         }
 
-        // Otherwise animate
-        
         guard delta.hasChanges else {
             itemProvider.calculatingItems = nil
             calculationCompletion()
             return
         }
-        
-        let itemAnimationStlye: AnimationStyle = {
-            guard let animationDelegate = animationDelegate else { return .preciseAnimations }
-            return animationDelegate.preferredItemAnimationStyle(for: delta)
-        }()
-        
+
         let startingItemCount = itemProvider.items.count
 
         DispatchQueue.main.async { [weak weakItemProvider = itemProvider, weak weakViewProvider = viewProvider] in
+
             guard let strongItemProvider = weakItemProvider,
                 let strongViewProvider = weakViewProvider,
                 let targetView = weakViewProvider?.view else {
@@ -340,14 +332,36 @@ private extension ItemDataCalculator {
             if targetView !== view {
                 targetView.reloadData()
             }
-            
+
+            let itemAnimationStlye: AnimationStyle = {
+                if view.frame.isEmpty { return .reloadData }
+                guard let animationDelegate = animationDelegate else { return .preciseAnimations }
+                return animationDelegate.preferredItemAnimationStyle(for: delta)
+            }()
+
             switch itemAnimationStlye {
             case .reloadData:
                 updateData()
                 targetView.reloadData()
                 calculationCompletion()
-                
-            case .reloadSections:
+            case .reloadSections,
+                 .preciseAnimations:
+                // Short circuit if there are too many items
+                guard deltaChangeTooLarge == false else {
+                    self._updateSections(section: section,
+                                         viewProvider: viewProvider,
+                                         viewDelegate: viewDelegate,
+                                         updateData: updateData,
+                                         calculationCompletion: calculationCompletion)
+                    return
+                }
+            }
+
+            // Otherwise animate
+
+            switch itemAnimationStlye {
+            case .reloadData,
+                 .reloadSections:
                 let sectionUpdate = SectionUpdate(section: section,
                                                   delta: delta,
                                                   delegate: viewDelegate,

LiveCollectionsFramework/LiveCollections/Classes/Internal/SectionDataCalculator.swift

@@ -202,13 +202,15 @@ private extension SectionDataCalculator {
         typealias SectionUpdateCompletion = () -> Void
 
         let performSectionUpdates: (SectionUpdateCompletion?) -> Void = { sectionUpdateCompletion in
-            let sectionAnimationStlye: AnimationStyle = {
-                guard let animationDelegate = animationDelegate else { return .preciseAnimations }
-                return animationDelegate.preferredSectionAnimationStyle(for: sectionDelta)
-            }()
-            
+
             DispatchQueue.main.async {
 
+                let sectionAnimationStlye: AnimationStyle = {
+                    if view.frame.isEmpty { return .reloadData }
+                    guard let animationDelegate = animationDelegate else { return .preciseAnimations }
+                    return animationDelegate.preferredSectionAnimationStyle(for: sectionDelta)
+                }()
+
                 let sectionUpdateData = {
                     sectionProvider.sections = sections
                     sectionProvider.items = items
@@ -291,19 +293,21 @@ private extension SectionDataCalculator {
                 sectionProvider.items = items
                 sectionProvider.calculatingSections = nil
             }
-            
-            let itemAnimationStlye: AnimationStyle = {
-                guard let animationDelegate = animationDelegate else { return .preciseAnimations }
-                return animationDelegate.preferredItemAnimationStyle(for: itemDelta)
-            }()
-            
+
             DispatchQueue.main.async { [weak weakView = view] in
+
                 guard let strongView = weakView else {
                     updateData()
                     calculationCompletion()
                     return
                 }
-                
+
+                let itemAnimationStlye: AnimationStyle = {
+                    if view.frame.isEmpty { return .reloadData }
+                    guard let animationDelegate = animationDelegate else { return .preciseAnimations }
+                    return animationDelegate.preferredItemAnimationStyle(for: itemDelta)
+                }()
+
                 switch itemAnimationStlye {
                 case .reloadData:
                     updateData()
@@ -362,19 +366,21 @@ private extension SectionDataCalculator {
         let insertedIndices = [Int](startingCount..<(startingCount + appendedItems.count))
         let sectionDelta = IndexDelta(insertions: insertedIndices)
 
-        let sectionAnimationStlye: AnimationStyle = {
-            guard let animationDelegate = animationDelegate else { return .preciseAnimations }
-            return animationDelegate.preferredSectionAnimationStyle(for: sectionDelta)
-        }()
-        
         DispatchQueue.main.async { [weak weakSectionProvider = sectionProvider, weak weakView = view] in
+
             guard let strongSectionProvider = weakSectionProvider,
                 let strongView = weakView else {
                 updateData()
                 calculationCompletion()
                 return
             }
-            
+
+            let sectionAnimationStlye: AnimationStyle = {
+                if view.frame.isEmpty { return .reloadData }
+                guard let animationDelegate = animationDelegate else { return .preciseAnimations }
+                return animationDelegate.preferredSectionAnimationStyle(for: sectionDelta)
+            }()
+
             switch sectionAnimationStlye {
             case .reloadData:
                 updateData()

LiveCollectionsFramework/LiveCollections/Classes/Public/Protocols/Visual Update/DeltaVisualUpdateProtocols.swift

@@ -17,7 +17,10 @@ public protocol DeltaUpdatableViewDelegate: CollectionDataManualReloadDelegate,
 public protocol SectionDeltaUpdatableViewDelegate: CollectionDataManualReloadDelegate, CollectionSectionDataAnimationDelegate { }
 
 public protocol DeltaUpdatableView: AnyObject {
-    
+
+    /// Basic view frame getter
+    var frame: CGRect { get }
+
     /// Basic reloadData function
     func reloadData()
 
@@ -40,6 +43,10 @@ public protocol DeltaUpdatableView: AnyObject {
 
 public protocol SectionDeltaUpdatableView: AnyObject {
 
+    /// Standard view frame getter
+    var frame: CGRect { get }
+
+    /// Basic reloadData function
     func reloadData()
 
     /**

LiveCollectionsFramework/LiveCollections/Classes/Public/Synchronizer/CollectionDataSynchronizer.swift

@@ -112,7 +112,11 @@ public final class CollectionDataSynchronizer: DeltaUpdatableView {
     }
 
     // MARK: DeltaUpdatableView
-    
+
+    public var frame: CGRect {
+        return view?.frame ?? .zero
+    }
+
     public func reloadData() {
         view?.reloadData()
     }