Cells with image view and passed a model for networking: what happens when reused?

Question

I have a table view whose cells show an image that is downloaded by using a URLSessionDownloadTask. I've seen several tutorials/posts dealing with the common scenario of having to check that the cell that called to download a certain image has not been reused and still has to show such image, either by setting and checking later the cell's tag, or holding and checking later the URL of the image called/received.

But in those tutorials/posts, the network task is called either from the view controller in the tableView(_:cellForRowAt:) method (then I see the tag of the cell is checked), or from the UITableViewCell subclass (then it seems that the URL of the image is usually checked). In those cases, I understand that a cell could had been already reused when the completion of the download task is called. But my scenario is a bit different and I'm not so clear about if that could also happen:

In my tableView(_:cellForRowAt:) I pass a model object to the cell. Then, it is the model who calls the download task, not the cell itself. This is the method in the UITableViewCell I call from tableView(_:cellForRowAt:) to configure each cell with the appropriate model:

func configureCell(_ model: MyCellModel) {
    // Some label's texts are set here

    model.getPicture { (picture) in
        imageView.image = picture
    }
}

And getPicture is like this:

func getPicture(completion: @escaping (UIImage?) -> Void) {
    let request = URLRequest(url: url!)
    let task = session.downloadTask(with: request, completionHandler: { (fileUrl, response, error) in
        if let data = try? Data(contentsOf: fileUrl), let image = UIImage(data: data) {
            DispatchQueue.main.async {
                completion(image)
            }
        } else {
            DispatchQueue.main.async {
                completion(nil)
            }
        }
    }) 

    task.resume()
}

So, when tableView(_:cellForRowAt:) is called and a cell is reused, it is "injected" a new model. And it is that model which then performs the call to download the picture the cell needs at that moment. The cell doesn't hold a reference to its model.

Is then possible here for a cell to get the image that needed before being reused and having called for a new one?

EDIT: Maybe I should explain better which is my concerning here: for my scenario, it is not a problem if I start downloading an image, then the cell is reused, and then its model "dies" and the download does not finish and/or I don't get such image in the cell, because I don't need that image anymore.

My concern is the opposite: if a cell starts downloading an image, and before it gets such image the cell is reused and injected a new model, I understand its former model should be killed. But, could its completion closure still be called, and then get in the cell the former image I don't need anymore? Maybe because its @escaping? Should I then take care of checking which image I'm getting in the cell for this scenario also?

Answer 1

The cell cannot take care of the data then. You have a model that is retrieving the data for the cell and after retrieving, the model dies (no references are held)..

In this case, the model has to do some sort of caching.. OR the networking layer has to do caching.

The way AFNetworking does it (pseudo code):

class model {
    func download(url: URL, completion:(img: UIImage?, error: Error?) -> Void) {
        if let img = cache.find(url) {
            completion(img, nil);
        }
        else {
            taskManager.downloadImage(url, {(img, err) in 
                cache.put(url, img)
                completion(img, err)
            });
        }
    }
}