Operation and

operation cues are a set of APIs built on top of Grand Central Dispatch.

Their high level APIs offering a bit more control and

flexibility than GCD's lightweight APIs.

They offer features like dependencies,

where you can make one operation depend on the other.

For example, we want to download a photo and once it's downloaded, resize it.

There are other features like canceling operations, querying their state, and

finally, seeing how many operations are there in a queue.

In addition, your code can easily be debugged and

managed when using operation in operation queues.

The main reason you want to use operation and operation queues

is because you want to manage what's being processed in the background.

Unfortunately, with GCD, you sense something to be

processed in the background and then you don't really have much control over it.

Whereas with operations, you have a lot of control over the tasks.

In our example, we're downloading images.

Ideally, we want to download only the images for cells that are visible.

This will make our app a lot more efficient and performant.

So let's see how we can replace GCD for image downloading and

use operations instead.

So coming back to our project.

As we had previously seen,

we had modified our ImageTableViewCell to use a Grand Central Dispatch.

We accessed the global concurrent queue and

used the asynchronous method to download the image data.

Now instead of using Grand Central Dispatch in this example,

we're going to use operations and operation queue.

Now an operation is a unit of work.

So whatever we performed here would be part of our operation,

and operation queue is synonymous to the DispatchQueue.

Basically, we'll add our operation to the operation queue.

Now, the great thing about Grand Central Dispatch is that it's

a block-based interface, right?

So, you just provide a block of code and you dispatch it to a queue.

Whether it's the main queue, the global queue, any queue.

With operation and operation queue, it's not so.

Because operation and operation queues are built on top of GCDs,

they are more object oriented-based.

You have to subclass an operation and

then provide it the unit of work that you want to perform.

And then of course, send it off into the operation queue.

So, let's create this subclass.

And we'll say a new file, a Swift file.

And we'll say, image.

We'll just call it an imageDownloader.

We're going to import UIKit.

We'll say class imageDownloader, which is a subclass of operation.

We're going to have a constant of type photo.

We're gonna declare a designated initializer, which takes in a photo

and sets it to our constant.

So, the next thing, where our unit of work is performed,

just like in our ImageTableViewCell, we had all of this

going on where we download the image data from a specific URL.

That's exactly what we're going to do inside our ImageDownloader.

But where do we do this?

Here, we had this convenient async method where you just provided a block of code.

Well, in the operation, you have this method call main,

which we have to overwrite.

If you command click here, you can look at what this definition looks like.

And here you can see this main method.

This is where our unit of work will be performed.

There are other methods that you can note, which is start, isCancelled.

You have a Cancel method.

Of course, you can query it for a status.

You have methods like isExecuting, isFinished, isConcurrent, all right?

So we have to override the main method.

So first and foremost, the compiler is complaining that we need to provide it

with an override directive because we are overwriting it from the superclass.

So the first and foremost thing we need to check, if isCancelled.

So if this operation is cancelled, then we simply return.

We don't need to do anything here.

So we're gonna create another constants in another constant.

We're going to call this imageData =

Data(contentsOf: url, photo.imageURL).

All right, so while this data is being downloaded,

it's entirely possible that this operation was canceled once again.

So if it has been canceled, then we're going to check if it's been canceled, and

then return.

Now the compiler is complaining.

Let's see what it's complaining about.

It says, cannot convert value.

Right, so we need to provide it a URL cuz that is a string.

So I'm going to convert that.

And it's still complaining.

I think we need to implicitly unwrap this.

And it's still complaining.

So that's the warning.

Right.

So the error is called can throw but it is not marked with try.

So the error is not handled.

So this initializer actually throws,

so we need to put in a try.

So we'll just say try?,which will give us an optional.

And then, if it successfully downloaded the data,

then we're going to unwrap it and

say if let data= imageData, data.length >0.

And that's complaining, and says lend has been renamed to count, right?

So will use counts.

So basically, we're just checking to see we actually got some data.

And if we did, then we're simply going to add it to our ImageCache.

So you add photo.imageURL.

So we need to add an image.

So let's convert this to a UIImage.

We'll say let image =.

All right, so so far we don't have we're not implicitly unwrapping anything.

And this code is pretty safe.

We have an error somewhere.

Right, okay, so we need to implicitly unwrap the image.

But here we're already checking to see if we actually have data.

And if we do, then we're creating an instance of image.

And then we're going to add it to our cache.

Great, so as you can see,

this is a lot more involved than using Grand Central Dispatch.

But as I mentioned, there's a lot of advantages to using operations and

operation queues.

One of them is you can query it for state or status, as we had seen here.

You can check if it's executing, finished,

it's concurrent, it's ready, all of those things.

You can check the state of your operation.

You can cancel your operation.

You can check how many operations have been queued.

So, all of this operation management is being done.

It is a lot of heavy lifting if you have a lot of

concurrent tasks going on within your application.

So you want to use all of this management layer that the operation queue and

operation provides you with.

Because with the dispatch async, once the work has been dispatched,

then you really don't have a lot of control over it.

All right, so going over to our ImageTableViewCell.

What we had here was in our configure method, we got our image from the cache.

And if we didn't have it in the cache, then we loaded from the network.

So we're going to do something very similar here.

We're going to use the operation that we just created,

the ImagDownloader operation.

So we're gonna create a property that simply says

ImageDownloader, Of type ImageDownloader.

And this will be an optional.

So instead of saying, load image, we'll say,

set up or configureImageDownloader(for photo).

So let's copy this method signature.

And we're going to create a new method that doesn't return anything.

And basically it takes in a photo of type Photo.

You have to put in a : here.

So we're gonna configure an ImageDownloader for a photo.

Sorry we're passing a photo here, all right.

So say let downloader = ImageDownloader,

and we pass in a photo, great.

Now what happens after it downloads a photo?

Just like here, once it downloaded a photo we set it to the imageView,

we have to do the exact same thing here.

So we'll say, downloader.completionBlock.

We can say once you have completed whatever operation you're doing,

in our case once you've downloaded the image, you have to do a bit more work.

Whenever you're doing work inside an operation,

you always have to check if that operation has been cancelled.

So you have to check to see

if downloader.isCancelled, then simply return.

If not, then do something.

Well, in our case, that something is setting the ImageView with the image.

Now, we could have created a property within downloader

to download it to an image property.

But since we're saving it inside our cache, because we're still using

that caching mechanism, we're just going to get it from the cache.

Now remember, the operations are being done on a background queue.

So if we're updating the UI, we have to do it on a main queue.

So I'm going to just copy this code here.

And I will paste it here.

Now, since we don't have the image, we're going to get it from our ImageCache.

So, we'll say, ImageCache.shared.get, oops.

And we'll pass it the photo.imageURL().

All right, so, we've configured our operation.

We have our operation property for our imageTableViewCell.

And we're no longer using this loadImage method, we can even comment it out here.

We'll just comment that out so there 's no confusion.

And then going back to our PhotosTableViewController.

Now to manage operations, we need an operation queue.

Now creating an operation queue is very straightforward.

We'll create a lazy property.

So we'll say lazy var downloadQueue is equal to,

well, is of type OperationQueue.

And I create a queue.

We'll create a variable called queue of type OperationQueue.

We're creating a lazy property here because we don't want it to be

instantiated unless it's necessary, or until it's time for it to be instantiated.

It's important that your name your queue so

that the name shows up in instruments or in debugger.

So we're gonna call this the Image Downloader Queue.

Now one thing we can do since we're debugging and

testing this operation queue out, we can set the maxConcurrentOperationCount to 1.

What this will do is it'll allow us to see the operations in

our queue finishing one-by-one.

Of course, you must leave this part out if you're building the application for

production.

Because you want to let the system handle how many operations it can do it at once.

So how do you decide how many operations it can run at once?

Well, that all depends on the hardware, it depends on the resources, it depends on

the number of cores in the CPU, on the amount of memory available at that time.

So, it's best for

the platform to decide how many number of threads it can create at once.

And we should not be making that determination.

And then, finally, returning the queue.

And we need the open and close parentheses so that it's going to execute this block

of code when we ask for our downloadQueue.

All right, so we've created the downloadQueue.

Lastly, we need to add our download operation to our downloadQueue.

So we're going to do that in our cellForRowAt indexPath method.

So after we have configured our imageTableViewCell,

we're going to check to see if we have a downloader.

So, we'll say, if let downloader = imageTableViewCell.ImageDownloader.

So, if we do have a downloader, we're going to add it to our downloadQueue.

So, we'll say, add operation(downloader).

All right, one thing that I forgot to do was in our imageTableViewCell.

Once this downloader has been configured, every time it dequeues,

it's still going to be configured.

So we need to set it to nil every time a imageTableViewCell is being dequeued.

Why is that so?

Because it's associated to that specific image.

Remember, the cells are being reused over and over again.

We don't create, if we have 1,000 JSON objects in our photos' JSON,

then that doesn't mean that 1,000 cells are being created.

At the most it's whatever amount of visible cells there are, like eight,

ten, which are being reused over and over again.

So, when we're reusing a cell, we want to make sure that the ImageDownloader

has been cancelled and set to nil.

So, we're gonna do self.imageDownloader?.cancel.

And then, self.imageDownloader = nil.

Great, so, we're reusing our ImageDownloader and

we're setting it to nil.

We're configuring it when necessary.

And we're adding it to the downloadQueue when we're retrieving the cell.

So, let's run our application to see if we successfully implemented operations and

operation queues.

And, it looks like something went wrong.

So, let's go back to our cell.

And we're checking to see if we get it from cache.

If not, we're configuring our ImageDownloader.

And we're creating this local variable called downloader, but

we're never setting it to our property.

[LAUGH] So, do not forget that folks.

So self.ImageDownloader = downloader.

Perfect, now lets run our application and see if this marvel works.

All right, we're not losing user activity.

So our user interface is responding to touch events and scroll events.

Now we can scroll.

And as you can see, this is responding pretty well.

It's executing the downloading in the background, and as cells become visible,

it is showing us the necessary photo that belongs to that particular cell.

And I'm scrolling pretty fast here.

And as you can see, there's no loss in frames.

There's no lag.

There's no stuttering. So there you have it,

we successfully implemented operation and operation queues,

which provided similar functionality to our Grand Central Dispatch approach.

Concurrency is a powerful tool to take advantage of the computing power of

modern multi-core CPU's.

GCD or operation queues make it easier to execute more code concurrently.

However, these technologies do not guarantee to make our apps more efficient

or responsive.

It is our responsibility as developers to know what is going on with our code and

the side effects we're introducing.

Before introducing concurrency, study your application's needs to understand where

and how introducing concurrency will benefit the performance and

responsiveness of your app.

It's not a be-all, end-all solution, but

it is yet another important tool in our tool belt as developers.

So make sure you understand it wisely and use it carefully.

When carefully implemented,

concurrency has great advantages to the performance of your application.

As always,

check out the teacher's notes to learn more about this amazing technology.

This is Ahmed signing out until next time.