Improving scrolling in complex collection views construct

Question

I am working on a flexible form component, that consists basically of a UIViewController with a collection view, that can have infinitely nested view controllers of that class. In its current state, it works fine more or less, but unfortunately the scrolling is choppy and I haven't found a solution for that problem yet. Maybe someone of you have an idea for a good solution. What I've also tried is to cache the view controllers, which helped to achieve smooth scrolling, but unfortunately with that solution, I started to get displaying issues. Sometimes the content of cells just disappeared and I couldn't figure out the reason for that.

Here is the link to the complete project: https://d.pr/f/0ij57m

The main parts of this project are basically this FlexibleViewController (designed through the storyboard)

class FlexibleViewController: UIViewController {

    var dataForDatasource = Array<Component>()
    var datasource: UICollectionViewDataSource?

    @IBOutlet var collectionView: UICollectionView! {
        didSet {
            let datasource = MyDatasource(data: dataForDatasource, parentController: self)
            self.datasource = datasource
            self.collectionView.dataSource = datasource
            self.collectionView.delegate = datasource
        }
    }

    override func viewWillTransition(to size: CGSize, with coordinator: UIViewControllerTransitionCoordinator) {
        super.viewWillTransition(to: size, with: coordinator)
        self.view.setNeedsLayout()
        self.collectionView?.collectionViewLayout.invalidateLayout()
    }

    func invalidateLayout() {
        self.collectionView.collectionViewLayout.invalidateLayout()
        if let controller = self.parent as? FlexibleViewController {
            controller.invalidateLayout()
        }
    }
}

And this Datasource:

    class MyDatasource: NSObject, UICollectionViewDataSource, UICollectionViewDelegate {

    weak var parentController: UIViewController!
    var components: Array<Component>!

    init(data: Array<Component>, parentController: UIViewController) {
        self.components = data
        self.parentController = parentController
    }

    func collectionView(_ collectionView: UICollectionView, numberOfItemsInSection section: Int) -> Int {
        return components.count
    }

    func collectionView(_ collectionView: UICollectionView, cellForItemAt indexPath: IndexPath) -> UICollectionViewCell {
        let component = components[indexPath.row]

        var cell: UICollectionViewCell?
        if component.subComponents.count > 0 {
            let collectionCell = collectionView.dequeueReusableCell(withReuseIdentifier: "collection", for: indexPath) as! TestCell

            let storyboard = UIStoryboard(name: "Main", bundle: nil)
            let vs = storyboard.instantiateViewController(withIdentifier: "flexi") as! FlexibleViewController
            vs.dataForDatasource = component.subComponents

            parentController.addChild(vs)
            collectionCell.addSubview(vs.view)
            vs.collectionView.backgroundColor = component.backgroundColor
            vs.didMove(toParent: parentController)
            collectionCell.controller = vs

            cell = collectionCell
        } else {
            cell = collectionView.dequeueReusableCell(withReuseIdentifier: "default", for: indexPath)
            cell!.backgroundColor = component.backgroundColor
        }

        return cell!
    }
}

extension MyDatasource: UICollectionViewDelegateFlowLayout {

    func collectionView(_ collectionView: UICollectionView, layout collectionViewLayout: UICollectionViewLayout, sizeForItemAt indexPath: IndexPath) -> CGSize {
        var sizeForItem: CGSize
        let component = components[indexPath.row]
        var width = Int(collectionView.frame.size.width)
        if component.width != -1 && component.width < width {
            width = component.width
        }

        var height: Int = 50
        if component.subComponents.count > 0 {
            let collectionView = UICollectionView(frame: CGRect(x: 0, y: 0, width: width, height: height), collectionViewLayout: UICollectionViewFlowLayout())
            let datasource = MyDatasource(data: component.subComponents, parentController: UIViewController())
            collectionView.dataSource = datasource
            collectionView.delegate = datasource
            collectionView.reloadData()
            height = Int(collectionView.collectionViewLayout.collectionViewContentSize.height)
            sizeForItem = CGSize(width: width, height: height)
        } else {
            sizeForItem = CGSize(width: width, height: height)
        }
        return sizeForItem

    }
}

As you can see, when the component has more than 1 component, a new controller with a collection view is instantiated through the storyboard, wich is probably not not ideal (although not as expensive as I expected). I tried to re-init all controllers in viewDidLoad, but like I said in my introduction, I encountered display issues with that solution.

The cell is pretty simple and looks like that:

class TestCell: UICollectionViewCell {
    var controller: UIViewController?

    override func prepareForReuse() {
        super.prepareForReuse()
        controller?.willMove(toParent: nil)
        controller?.removeFromParent()
        controller?.view.removeFromSuperview()
    }
}

The component class looks like this:

class Component {
    var generatedId = NSUUID().uuidString
    var identifier: String?
    var subComponents = Array<Component>()
    var width: Int! = -1
    var type: String! = "default"
    var backgroundColor: UIColor! = .white
    var isOpen: Bool = false
}

Thanks in advance for any help! :-)

Answer 1

You should take a look at Apple's excellent documentation on Prefetching Collection View Data

It contains a (Swift) example project and makes heavy use of OperationQueue and NSCache .

The basic idea is to "prefetch" and cache the next items before they get displayed to make a smooth scrolling. When scrolling back the items are fetched from the cache.