[MUSIC]

We've got our collection view looking like, well, a collection view.

But right now, it's only displaying that one photo loaded right into the bundle.

Now this isn't gonna impress anyone, and technically speaking, it's kinda lame.

Why don't we connect our lonely little app to the Internet?

I hear it's all the rage.

So to get our hands on the GIFs from the GIPHY API,

we're going to employ a few tools, NSURLSession, and the GIPHY API.

That might seem intimidating, but we'll go step by step.

We'll use NSURLSession for the network request and

GIPHY's API to retrieve our GIFs, and Meta Data.

Let's start with the first step where we'll make an asynchronous

network request using NSURLSession.

Now, it's important to highlight that this will be asynchronous request.

Since we wouldn't want our app just sitting around there and

waiting because the GIPHY's API decided to check out instead of check in.

Imagine, if you will, that our app is a long multi-lane highway.

Yes, just like that.

Well, our app is capable of executing many tasks at once.

And these tasks are organized into queues each represented by a lane of traffic.

Our main queue, right here in the middle,

is the only place where we can update the user interface.

You can do other things there as well, but you need to be mindful of the risks.

Let's say our app is humming along and a user taps a button to refresh the data.

That kicks off a Network Request and our faithful friend the UIActivityIndicator.

So if our Network Request decides to respond slowly or

stop all together, everything behind it will start to backup.

The spinning gear will keep spinning.

The other buttons in the app won't be responsive.

And all the other drivers stuck behind the truck will start to get road rage-y.

Luckily, there's a very simple solution to all of this.

We instead, place our Network Request on a different queue,

where it can handle its business asynchronously.

That way, if it is slow, it won't gum up the works.

When it's done, which could be just a fraction of a second if we're lucky,

we get our data and we can then display it using the main queue.

So that's the theory behind why asynchronized network calls are so useful.

But how does NSURLSession in particular helps us get the job done?

Well, first of all NSURLSession is a class.

But when developers say NSURLSession,

they are often referring to a whole group of related classes.

You'll use NSURLSession, the class, to create an NSURLSession task.

You can actually choose from three types of tasks,

all subclasses of NSURLSession task.

And those choices are NSURLSession data task,

NSURLSession download task, and NSURLSession stream task.

We'll use a download task in our app.

A task will make an NSURL request,

which will contain all the information we need to make a request.

When the request completes, we'll get NSURL response.

So let's take the theory and jargon that we just rattled off and

see how it looks in our app.

Now, we could put all our networking code in viewDidLoad, even just temporarily.

But I know we're going to want to move it into it's own method eventually.

So let's do just that right now.

And how do I know we'll want it in its own methods?

Well, for two reasons.

You don't want to clutter up viewDidLoads with unrelated code.

And the act of downloading our data isn't just going to happen when we load the app,

right?

It will happen whenever we refresh the GIFs or the images.

Now with that in mind, we'll create a method called refreshImages.

And we will call that method from our viewDidLoad.

Okay, let's add some meat to our method here.

First, we'll create a session which we'll call, well, session.

So we'll do NSURLSession,

Session is equal to [NSURL Session sharedSession].

Next, we'll create our download task.

So let's go over to our documentation.

So we'll option click on NSURLSession.

And as you can see here, that it talks about the class and

how it provides an API for downloading content.

And if we scroll down,

you will see that it talks about there are different types of tasks.

There are data tasks, upload tasks, download tasks.

So what we want to do is use our download task.

So we'll use NSURLSessionDownloadTask.

And we'll create this task.

I'll say session downloadTaskWithURL,

and a completion handler.

So we need to provide it with a URL, which we will in a second, and

that's our completion handler.

So within our completion handler, we'll add an NSLog.

And we'll come back to the NSLog and we can just print out the response.

We'll say response.

All right, so we have an error that we haven't specified a URL, so

let's go ahead and do just that.

So we'll create and NSURL,

URL= [NSURL URLWithString.

So, of course, we need to provide a URL which we don't have yet.

So let's look at the GIPHY API.

You can go to api.giphy.com, and it has this great

landing page with this beautiful GIF right here.

And there's Search, there's Trending, which is exactly what we're going to use.

Apparently, they have GIPHY Translate, Roulette, Stickers and so

many other things.

So it says down here with this blue button, get started with the GIPHY API.

And if you click on it, it takes you to their GitHub page.

Once, again, they have that beautiful GIF and some documentation.

The first thing you'll notice that they talk about is their Public Beta API Key.

They say that the Giphy API is open to the public, and we have instituted a simple,

single public beta key system to let anyone try it out.

So this is great.

So you don't have to register, and get a API key for your specific app,

only if you're using it for commercial purposes.

So if you do build an app that uses a Giphy API and it's a commercial app,

then you should apply for a production key, using this URL right here.

All right, so overview, these are the end points that it provides.

We're going to use the trending endpoint.

So I'm going to click on that.

And simply, we have to copy and paste this URL.

Now, one thing that you want to make sure,

at least in my case, I wanna make sure that the results are pg.

You have these different ratings.

This is young, we have pg, pg-13, r.

I don't want any rated r images because this is a family friendly course.

So I'm going to add a rating parameter to my URL.

We'll say rating = pg,

pg stands for parental guidance.

All right, so now we have a URL.

All right, so now Xcode has stopped complaining about compiler errors.

But we still have this unused variable.

You can see that there's a compiler warning that says, unused variable task.

So why have we gone to all this trouble and not even used this task object?

Well, we can do that with one simple line.

We'll do [task resume], and

that basically executes this task.

So now we can go ahead and run our app, Uh-oh,

looks like we've got an ATS, an app transport security issue.

If you don't know what an ATS is, you should probably spend at least a couple of

minutes perusing the links below in the teacher's notes.

So according to this message,

what says HTTP resource load is insecure.

So we can add an exception or we can change our URL.

So we're not using a secure URL.

You'll notice that this is simply HTTP and not HTTPS.

HTTPS uses SSL, which provides encryption when you're sending and receiving data.

So all we need to do is add an s here.

Of course,

you need to make sure that the API that you're accessing has a secure access.

Most websites and APIs do have https protocol for communicating with them.

But you should probably just check with the vendor of API.

All right, so let's go to run our app once again.

And hopefully, this time it works and we don't get an ATS error.

All right, there you go.

We got an output, so this is our response.

It isn't exactly Greek, but it's not exactly a summer beach read.

So what does this say?

Well, this is the response that's talking about, you get http status code.

So it's saying this response was successful.

And it's just giving us some more meta data about our request that we

sent to the server.

So our response does contain content.

So let's try to print out that string.

So what we'll do is, we'll do an NSString responseText,

= [NSString

alloc] initWithContentsOfURL:Location,

encoding:NSUTF8StringEncoding, and

error will be nil.

So where did I get this location from?

Well, our completion handler contains this parameter called location

which is where the file is stored or the response is being stored.

And the encoding, it's pretty much a standard encoding option and

the error will be nil.

So let's go and print out this response text.

Testing this response, I'll say responseText.

And so now, we see a JSON response.

This isn't exactly Greek, but we see a bunch of URLs.

And these are probably URLs for all the trending GIFs on the GIPHY website.

So next, we will see how we can make sense of this response text and

create structured data from it.