To use our operation and

get image data we're going to add come code to the album list data source.

So let's navigate there.

After a cell has been set up with the initial data in self for

row index path we'll fire off a request for the album artwork.

This way we know that the user now sees actual album data on screen and

in the background we're going to let this request process and

hopefully reload with a new Artwork.

So in here we'll say, if album.artworkstate = placeholder.

Remember we are only doing this,

we are only going to fire off a request if the current state is a placeholder,

indicating that we haven't attempted to download the image yet and

the operation is neither failed nor completed successfully.

So inside this if statement, we're going to call a new method.

And let's go ahead and define that at the bottom.

We'll say func downloadArtworkForAlbum.

And this is going to be an instance of album.

In this method, we're going to create an operation using the album,

add it to the operation queue, and execute the logic.

Remember though that we also want to keep track of the actual row

which this album is in.

Why is that again?

When we fire off a download for the artwork, is that row scrolls off screen,

there's no reason to continue the download and we would have to cancel it.

In addition, if we reloading a table view and

we already have an operation processing in the background,

to download artwork for that particular row we need to know that.

We need to keep track of that so we don't create a duplicate operation and

do the exact same work over again.

Now, we need to keep track of this in a very simple way.

And one easy way of getting this done is associating a download operation

with a rows index path.

So we'll say, downloadArtworkForAlbum atIndexPath and

we include the IndexPath as an argument.

To keep track of the operations and to create a queue, let's create a new type.

So in networking, again New File, swift file,

and we'll name this Pending Operations.

In here we're going to define a type with two simple stored properties.

So we'll create a class called PendingOperations, that contains

a dictionary, we'll name it downloadsInProgress.

This is a variable.

And the type is index path to operation.

And we'll just create an empty dictionary to start out.

And then we also want a download queue.

And this is an instance of operation queue.

So the first property here is a dictionary that keeps track of operations created and

the index paths they're associated with.

To figure out what operations are associated with an index path,

we can simply use the path as a key in this dictionary.

The second property is an instance of operation queue.

And this is the operation queue we're going to be adding our operations to.

We are not going to customize this in any way.

Now a couple of videos ago I mentioned that within operation queue, you could

customize it by defining the max number of operations executed at any time or

at the same time.

And we do this by sending a value on the max concurrent operation current property.

By leaving it as its default value,

we're going to let the system determine how many concurrent operations it can

execute simultaneously which honestly is the best approach.

Okay, so now let's use this very simple type back in the album list data source.

First, we need access to the dictionary to keep track of the operations we create or

as well as the operation queue to add the operations.

So let's add an instance of that new type as stored property,

let pendingOperations and we'll create an instance.

So inside this method.

We'll first start by checking to see if we've already created and

added an operation for a given row.

And the way we're going to do that, is, we'll check if we get a value back

by using this index path as a key in that dictionary.

So we'll say, if let, and we'll omit the name.

Because we don't care about the operation.

We just want to know if it's in the actual dictionary.

We'll say if let _ = pendingOperations.downloadsInProgress,

and using subscript notation, we'll use the indexPath argument as a key.

Now, if there is an operation,

if this succeeds, then we enter the if let statement.

It unwraps that operation.

We don't care about it, now that we know though,

that it does exist, that means we've already created an operation for

this cell, for this row, and it's currently processing in the background.

So we're not going to do anything else, and we'll return over here.

If we haven't though, if this if let statement fails,

that means that we do not have an operation for this album, this indexPath.

So now let's start the real work,

let's create an instance of the downloader with an album for that cell.

So let downloader = ArtworkDownloader, and it takes an album,

we'll pass the argument through.

So remember all the work we want to do is encapsulated in the main method

of the operation sub class,

including assigning the image back to this album instance.

When the operation completes, the album will then have an image and

we can display that image.

To do, however, we need to trigger the table views reload process so

that it can go through the data source methods again and

assign the album artwork we've fetched to the cells image view.

There are two things to consider here.

First off, how do we know when an operation completes?

And second, why should we reload the entire table view,

just to set up one row again with artwork?

If we do that the table view would reload every millisecond,

basically, as each individual download operation completed, because remember,

we're creating one for every single row.

Luckily, both these things are trivial to solve.

When an operation completes,

it executes a closure assigned to a store property called completion block.

So, any code that we want to execute when an operation is complete

we define in a closure and then assign it to that stored property.

So, I say downloader.completionBlock and to this we'll assign a closure.

Like everything we do with an operation

we first want to check if the operation is cancelled.

Even in here.

Because even after the operation is complete

we could still go ahead and cancel it.

So in your mind, think of it this way.

There's an operation running in the background.

It gets the image, it assigns it back to the album.

And then after that happens but before it reloads, the user scrolls off screen.

In that case, well we potentially could cancel it.

So in here we need to check if it's cancelled.

We'll say if downloader is cancelled then again,

we'll just return out of the block and do nothing.

If our operation wasn't cancelled, we'll just finish up by removing this operation

from our dictionary because since we're tracking active operations and

this is completed, it doesn't need to stay in that dictionary anymore.

And then we'll reload the table view.

The reloading of the table view is UI code so it needs to be done on the main thread

because remember the operation is executed on a dispatch queue in the background.

So here we'll call DispatchQueue.main.async.

And in here we want to indicate that the operation is done for

the purposes of tracking.

So it'll remove it from our dictionary.

We'll say self.pendingOperations.downloadsInProgres-

s.removeValue ForKey and we'll use the indexPath again.

That way when it's reloaded, if the previous operation was complete.

And let's assume that we don't have that artwork state property that

monitors whether we've done that or not.

The next time we come along, since we've removed it already.

This would fail and we would go through the process again.

After removing this operation, we need to reload the row so

that we run through the set up again and assign the right image.

Rather than reloading the entire table view,

we need to make sure we reload just the row whose operation completed.

And again, that's easy.

And we'll do self.tableview and the table view has a method reload rows.

And it takes an array of index paths.

So our paths are current index path in.

And then the animation down and then we say dot automatic.

It takes this array of index paths and reloads just those rows by calling

the data source methods and passing in the selective set of index paths.

Now, we have an error here.

And that's because we don't have a reference to the table view

outside of a data source method.

So, calling self.tableView is just going to return an error.

Well some of this by adding a stored property up at the top,

to hold on to our table view, so

let tableView UITableView, and then we'll modify our Init method.

So, we'll say tableView UItable view and

self dot table view equal table view.

Now let's go back down to our mtethod and it should work so there we go.

And this wraps up the code we want to execute when the operation is complete.

But remember, at no point here have we added the operation to the queue, nor

have we added the operation to this downloadsInProgress dictionary to keep

track of it.

This part is easy, though.

So first to add it to the dictionary, we'll say pendingOperations or

rather we'll add it to the queue first, dot download queue.addOperation.

And we'll pass in the downloader, pass through the downloader.

So that's all we need to do on our end.

The queue now keeps track of the operations and

executes them in a particular order when they hit that ready state.

We need to add one more line of code here and

then is to track the operation we just added.

So, pendingOperations.downloadsInProgress and using indexPath

as a key will assign the downloader which is our operation as a value.

When we add the operation to the queue we keep track of it in our dictionary.

When we call this method at the top,

we'll check that there is an operation in progress for the particular index path.

If there is, well then we don't do anything else.

But if there isn't, we start this process all over.

When the operation is done, as indicated in our completion block,

we'll remove that particular key rally pair from the dictionary.

Now, we went ahead and modified our init method, so

we will have an error in the album list controller dot.

And that's up at the top here in our data source because we now need a table view.

So, let's fix that.

We'll say, lazy var dataSource.

And we'll do this all over again.

So we'll copy this.

We'll again assign an executing closure.

So AlbumListDataSource =, we'll clone the closure and inside we'll say return, and

this time we're still going to initialize it with an empty array to start off.

But now, we can pass through self.tableView.

We're not done yet as always.

If you run the app now, you still won't see any album artwork.

But that's a simple fix, and

we'll wrap it up with the rest of the project in the next video.