Loading text content in background for reusable cell

Question

I'll jump right to it.

I have a cell with a titleLabel that prints a code and a detailTextLabel that prints a decoded version of that code. I have a plist dictionary database containing hundreds of etries like this: "JD" : "John Doe".

When setting the detailTextLabel in cellForRow I initially had a function that looked up the code in the plist and returned the decoded value. This worked, but the scroll was extremely sluggish.

I am now doing the same thing, but this time the decode lookup is happening in the background and returns the result in a callback closure. The scroll is smooth and it works fine. Almost. Sometimes the decoded value is returned for the wrong cell (since it is reused). Is this preventable?

Here is what I have in my cellForRow function:

override func tableView(tableView: UITableView, cellForRowAtIndexPath indexPath: NSIndexPath) -> UITableViewCell {

    //Create the cell
    let cell = tableView.dequeueReusableCellWithIdentifier("RosterCell", forIndexPath: indexPath) as UITableViewCell

    if let object = self.fetchedResultsController.objectAtIndexPath(indexPath) as? Object
    {

        cell.textLabel?.text = object.rawCode

        CodeDecoder.getDescriptionInBackground(CodeType.All, code: rawCode) { (description) -> () in

            if description.isEmpty == false {
                cell.detailTextLabel?.text = description
            }
            else {
                cell.detailTextLabel?.text = "No decode found for code: \(object.rawCode)."
            }
        }

    }
    else {
        cell.textLabel?.text = "Object not found."
        cell.detailTextLabel?.text = ""
    }


    return cell

}

I would greatly appreciate any help or ideas around this.

Answer 1

The other answers in here are good suggestions, but don't hit the root issue that you're having. Since you've already identified that you need to decode data asynchronously, now you need to figure out how to cancel that operation when you reuse that cell. I would venture a guess that the following method:

CodeDecoder.getDescriptionInBackground(CodeType.All, code: rawCode)

runs in a dispatch_async on some background queue.

Instead, you could use an NSOperationQueue which will generate NSOperation objects that can be cancelled. Then in your prepareForReuse method, you could cancel the operation that may be running. Here is a quick example of how this could work.

CodeDecoder

class CodeDecoder {

    let operationQueue: NSOperationQueue

    enum CodeType {
        case All
    }

    init() {
        self.operationQueue = NSOperationQueue()
        self.operationQueue.qualityOfService = .UserInitiated
        self.operationQueue.maxConcurrentOperationCount = NSOperationQueueDefaultMaxConcurrentOperationCount
    }

    func getDescriptionInBackground(#codeType: CodeType, code: Int, completionHandler: (String) -> Void) -> NSOperation {

        let operation = NSBlockOperation()
        weak var weakOperation = operation

        operation.addExecutionBlock {
            if let strongOperation = weakOperation {
                if strongOperation.cancelled {
                    return
                }

                // Run your decode logic

                if strongOperation.cancelled {
                    return
                }

                dispatch_async(dispatch_get_main_queue()) {
                    completionHandler("decoded value")
                }
            }
        }

        self.operationQueue.addOperation(operation)

        return operation
    }
}

CustomViewController

class CustomViewController: UIViewController, UITableViewDataSource, UITableViewDelegate {

    func tableView(tableView: UITableView, cellForRowAtIndexPath indexPath: NSIndexPath) -> UITableViewCell {

        //Create the cell
        let cell = tableView.dequeueReusableCellWithIdentifier("RosterCell", forIndexPath: indexPath) as CustomTableViewCell

        if let object = self.fetchedResultsController.objectAtIndexPath(indexPath) as? Object {
            cell.textLabel?.text = object.rawCode

            let operation = CodeDecoder.getDescriptionInBackground(CodeType.All, code: rawCode) { description in

                if description.isEmpty == false {
                    cell.detailTextLabel?.text = description
                }
                else {
                    cell.detailTextLabel?.text = "No decode found for code: \(object.rawCode)."
                }
            }

            cell.operation = operation
        }
        else {
            cell.textLabel?.text = "Object not found."
            cell.detailTextLabel?.text = ""
        }

        return cell
    }
}

CustomTableViewCell

class CustomTableViewCell: UITableViewCell {
    var operation: NSOperation?

    override func prepareForReuse() {
        super.prepareForReuse()

        if let operation = operation {
            if !operation.finished {
                operation.cancel()
                self.operation = nil
            }
        }
    }
}

Definitely double check the weakify / strongify logic. I can't test it since this isn't a fully compiling chunk of code. That should allow you to run all your decoding in the background, update the cells on the main thread and cancel the decoding operations when you need to reuse the cell.

Answer 2

Yes it is preventable.

Your problem comes from the fact that the CollectionViewCells are reused, and like you said if you load the text in the main thread it take a while until one cell is loaded and could be presented (because of the text lookup).

What you can do is a few things.

1) load the text you want to present in a earlier stage into an array (prior viewController, loading screen), then load the collectionViewCells from that array. This will cause the loading the drastically go down.

1.1) if you don't want to load all the data prior to the cell loading you can write a mechanism to load more data in the background once x amount of cells were loaded (or something like that)

2) you can create a UICollectionViewCells pool in a prior time. The cells will be loaded from that pool, and every new allocated cell will be inserted into that pool.

You can do several other mechanisms but these are the basics ones

Answer 3

Why you not create subclass of UITableViewCell(ObjectTableViewCell for example) with object property? and then, in tableView: rowAtIndexPath: your code will be like this:

let cell = tableView.dequeueReusableCellWithIdentifier("RosterCell", forIndexPath: indexPath) as ObjectTableViewCell
cell.object = self.fetchedResultsController.objectAtIndexPath(indexPath) as? Object
return cell

in ObjectTableViewCell class:

var object: Object? {
   didSet {
      //check object for nil and do other your code here
   }
}