How to reload UITableView data avoiding freeze - ios

Question

Some with experience can tell me what is the best way to execute a reloadData() from a UITableView on swift avoiding freeze?
I have a ViewController with a TableView, this shows a list of users in pairs of 10 rows. When the scroll show the last row - 1, in a background, the app request the next 10 users and then they are added to the rest of users for show now 20 users in the TableView.
When this is executed with a delegated method, the reload causes a freezing around 1~2 seconds and hasn't a comfortable navigation.
Any idea to solve this?

Answer 1

When new data coming, you don't need to reload the whole tableView. You just need to insert new rows accordingly. That won't cause any lag/freeze.
func didFinishLoadNewUsers(newUsers: [User]) {
tableView.beginUpdates()
//array of index paths for new rows at the bottom
var indexPaths = [NSIndexPath]()
for row in (currentUsers.count..<(currentUsers.count + newUsers.count)) {
indexPaths.append(NSIndexPath(forRow: row, inSection: 0))
}
//update old data
currentUsers.appendContentsOf(newUsers)
//insert new rows to tableView
tableView.insertRowsAtIndexPaths(indexPaths, withRowAnimation: .Automatic)
tableView.endUpdates()
}

Answer 2

If I understand your question correctly, your symptom is this:
The user scrolls to the bottom.
Scrolling is halted (because the bottom was reached).
Your controller notices that the user reached the bottom and starts downloading more rows.
There is an ugly delay while new rows finish downloading.
You insert the new rows, and now the user can resume scrolling.
The user is disappointed with your app now, because it stopped scrolling and delayed for no apparent reason. I believe this is what you meant by "freezing" and "uncomfortable navigation".
Solution:
Don't wait until the last row is displayed! For example: start with 40 rows and download 40 more rows when scrolling reaches a distance of about 15 rows from the bottom. That way, there's a good chance the download will finish quickly enough that it will look perfectly smooth to the user.
If you want to get really fancy, you can take scroll speed, row height, and server latency into account. But in my experience, none of that is really necessary for a smooth "infinite scrolling" experience.
With all due respect, you and the other responder are wrong to think that "reloading the whole table view" is responsible for this. UITableView.reloadData() is actually seamless (if the user hasn't reached the bottom yet).
Try this:
var shouldDownloadMoreRows : Bool {
get {
// This should return false if the server tells us there are no more rows.
// For example, if our last request for 40 got less than 40 rows, then we
// can probably assume there are no more.
// It should also return false if a request is currently in progress, or a
// request failed within the last 0.5 seconds or so, or if the controller
// is quitting (about to animate away).
return ...
}
}
func downloadMoreRows() {
...
// After the download finishes
didFinishDownloadingMoreRows()
}
func didFinishDownloadingMoreRows() {
// This will be smooth. It will not disrupt scrolling or cause any freezing or lag.
self.tableView.reloadData()
}
func tableView(tableView: UITableView,
willDisplayCell cell: UITableViewCell,
forRowAtIndexPath indexPath: NSIndexPath) {
let numRowsInSection = tableView.numberOfRowsInSection(indexPath.section)
if self.shouldDownloadMoreRows && indexPath.row + 15 >= numRowsInSection {
self.downloadMoreRows()
}
}