Swift: load images Async in UITableViewCell
The issue is that the .subtitle
rendition of UITableViewCell
will layout the cell as soon as cellForRowAtIndexPath
returns (overriding your attempt to set the frame
of the image view). Thus, if you are asynchronously retrieving the image, the cell will be re-laid out as if there was no image to show (because you're not initializing the image view's image
property to anything), and when you update the imageView
asynchronously later, the cell will have already been laid out in a manner such that you won't be able to see the image you downloaded.
There are a couple of solutions here:
You can have the
download
update the image todefault
not only when there is no URL, but also when there is a URL (so you'll first set it to the default image, and later update the image to the one that you downloaded from the network):extension UIImageView { func download(from url: URL, contentMode mode: UIView.ContentMode = .scaleAspectFill, placeholder: UIImage? = nil) { contentMode = mode image = placeholder URLSession.shared.dataTask(with: url) { data, response, error in guard let data = data, let response = response as? HTTPURLResponse, error == nil else { print("error on download \(error ?? URLError(.badServerResponse))") return } guard 200 ..< 300 ~= response.statusCode else { print("statusCode != 2xx; \(response.statusCode)") return } guard let image = UIImage(data: data) else { print("not valid image") return } DispatchQueue.main.async { print("download completed \(url.lastPathComponent)") self.image = image } }.resume() } }
This ensures that the cell will be laid out for the presence of an image, regardless, and thus the asynchronous updating of the image view will work (sort of: see below).
Rather than using the dynamically laid out
.subtitle
rendition ofUITableViewCell
, you can also create your own cell prototype which is laid out appropriately with a fixed size for the image view. That way, if there is no image immediately available, it won't reformat the cell as if there was no image available. This gives you complete control over the formatting of the cell using autolayout.You can also define your
downloadFrom
method to take an additional third parameter, a closure that you'll call when the download is done. Then you can do areloadRowsAtIndexPaths
inside that closure. This assumes, though, that you fix this code to cache downloaded images (in aNSCache
for example), so that you can check to see if you have a cached image before downloading again.
Having said that, as I alluded to above, there are some problems with this basic pattern:
- If you scroll down and then scroll back up, you are going to re-retrieve the image from the network. You really want to cache the previously downloaded images before retrieving them again.
Ideally, your server's response headers are configured properly so that the built in NSURLCache
will take care of this for you, but you'd have to test that. Alternatively, you might cache the images yourself in your own NSCache
.
If you scroll down quickly to, say, the 100th row, you really don't want the visible cells backlogged behind image requests for the first 99 rows that are no longer visible. You really want to cancel requests for cells that scroll off screen. (Or use
dequeueCellForRowAtIndexPath
, where you re-use cells, and then you can write code to cancel the previous request.)As mentioned above, you really want to do
dequeueCellForRowAtIndexPath
so that you don't have to unnecessarily instantiateUITableViewCell
objects. You should be reusing them.
Personally, I might suggest that you (a) use dequeueCellForRowAtIndexPath
, and then (b) marry this with one of the well established UIImageViewCell
categories such as AlamofireImage, SDWebImage, DFImageManager or Kingfisher. To do the necessary caching and cancelation of prior requests is a non-trivial exercise, and using one of those UIImageView
extensions will simplify your life. And if you're determined to do this yourself, you might want to still look at some of the code for those extensions, so you can pick-up ideas on how to do this properly.
--
For example, using AlamofireImage, you can:
Define a custom table view cell subclass:
class CustomCell : UITableViewCell { @IBOutlet weak var customImageView: UIImageView! @IBOutlet weak var customTitleLabel: UILabel! @IBOutlet weak var customSubtitleLabel: UILabel! }
Add a cell prototype to your table view storyboard, specifying (a) a base class of
CustomCell
; (b) a storyboard id ofCustomCell
; (c) add image view and two labels to your cell prototype, hooking up the@IBOutlets
to yourCustomCell
subclass; and (d) add whatever constraints necessary to define the placement/size of the image view and two labels.You can use autolayout constraints to define dimensions of the image view
Your
cellForRowAtIndexPath
, can then do something like:func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell { let cell = tableView.dequeueReusableCell(withIdentifier: "CustomCell", for: indexPath) as! CustomCell let record = dataSource[indexPath.row] cell.customTitleLabel.text = record.title cell.customSubtitleLabel.text = record.subtitle if let url = record.url { cell.customImageView.af.setImage(withURL: url) } return cell }
With that, you enjoy not only basic asynchronous image updating, but also image caching, prioritization of visible images because we're reusing dequeued cell, it's more efficient, etc. And by using a cell prototype with constraints and your custom table view cell subclass, everything is laid out correctly, saving you from manually adjusting the
frame
in code.
The process is largely the same regardless of which of these UIImageView
extensions you use, but the goal is to get you out of the weeds of writing the extension yourself.
After setting the image you should call self.layoutSubviews()
edit: corrected from setNeedsLayout
to layoutSubviews