Wednesday, February 7, 2024
HomeiOS Developmentswift - iOS UITableView with a number of performBatchUpdates known as comparatively...

swift – iOS UITableView with a number of performBatchUpdates known as comparatively rapidly causes scrolling to be jerky


I’ve an app utilizing UITableView the place an array knowledge is first fetched from a 3rd occasion api, then every merchandise of the array knowledge wants some native processing which takes a little bit of time, then that processed knowledge must be inserted into the UITableView. How lengthy every merchandise of the array wants for processing will fluctuate loads. As soon as the desk reaches the underside, extra knowledge is fetched and the identical course of happens once more.

The explanation I’m doing the processing on every merchandise of the array knowledge and including it one after the other as an alternative of processing all of it directly and inserting it suddenly is as a result of this permits me to indicate at the very least a few of the knowledge to the consumer instantly as an alternative of the consumer ready for a number of seconds earlier than all the info seems.

I’ve simulated my state of affairs with the next easy code with none API:

import UIKit
import SnapKit

struct Report : Codable {
    var title : String?
    var element : String?
    
    func titleAttributedText() -> NSAttributedString? {
        guard let t = title else {
            return nil
        }
        return NSAttributedString(string: t, attributes: [.foregroundColor : UIColor.white, .font : UIFont.systemFont(ofSize: 20, weight: .bold)])
    }
    
    func detailAttributedText() -> NSAttributedString? {
        guard let d = element else {
            return nil
        }
        return NSAttributedString(string: d, attributes: [.foregroundColor : UIColor.darkGray, .font : UIFont.systemFont(ofSize: 14, weight: .regular)])
    }
}

class ViewController: UIViewController, UITableViewDataSource {

    var tableView = UITableView()
    var information = [Record]()
    
    override func viewDidLoad() {
        tremendous.viewDidLoad()
        
        tableView.dataSource = self
        view.addSubview(tableView)
        tableView.snp.makeConstraints { make in
            make.edges.equalToSuperview()
        }
        fetchRecords()
    }
    
    func tableView(_ tableView: UITableView, numberOfRowsInSection part: Int) -> Int {
        return information.depend
    }
    
    func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
        let reuseIdentifier = "cell"
        let cell = tableView.dequeueReusableCell(withIdentifier: reuseIdentifier) ?? UITableViewCell(model: .subtitle, reuseIdentifier: reuseIdentifier)
        
        let file = information[indexPath.row]
        
        cell.textLabel?.numberOfLines = 0
        cell.detailTextLabel?.numberOfLines = 0
        cell.textLabel?.attributedText = file.titleAttributedText()
        cell.detailTextLabel?.attributedText = file.detailAttributedText()
        
        if indexPath.row > information.depend - 5 && !fetching {
            fetchRecords()
        }
        
        return cell
    }
    
    var fetching = false
    let group = DispatchGroup()
    let queue = DispatchQueue(label: "delayer", attributes: .concurrent)
    
    func fetchRecords(){
        fetching = true
        print("fetchRecords")
        DispatchQueue.international().async {
            for _ in 0...30 {
                let timeout: TimeInterval = Double(arc4random_uniform(10)) / 100 // 0 to 0.1 seconds delay
            
                self.group.enter()
                
                self.queue.asyncAfter(deadline: .now() + timeout) {
                    self.group.depart()
                }
                
                _ = self.group.wait(timeout: .distantFuture)
                
                
                DispatchQueue.most important.async {
                    self.tableView.performBatchUpdates {
                        self.information.append(Report(title: "New knowledge (self.information.depend + 1)", element: "Delay: (timeout)"))
                        self.tableView.insertRows(at: [IndexPath(row: self.records.count-1, section: 0)], with: .automated)
                    }
                }
                
            }
            self.fetching = false
        }
    }
}

My drawback is that when the self.tableView.performBatchUpdates is going on, the scrolling turns into uneven. If you scroll in the direction of the top of the listing and new knowledge is being inserted, the scrolling is uneven and body fee drops. The above code is ready to display it. In my actual app, it is loads worse.

This is a video recording:

https://i.imgur.com/Sy9iTFD.mp4

I’ve used Devices Time Profiler and I see the next:

enter image description here

As you possibly can see, the _performBatchUpdates is taking on numerous time.

I’m not positive find out how to repair it. Any strategies?



Supply hyperlink

RELATED ARTICLES

LEAVE A REPLY

Please enter your comment!
Please enter your name here

- Advertisment -
Google search engine

Most Popular

Recent Comments