Now we need to actually perform our API call.

You don't have a method to actually do that from our Etsy class yet so let's go

ahead and add in a new method to Etsy class so we can perform a call to our API.

This method needs to be public so that the activity class has access to it and

can call it.

Now the important thing is that this is void.

We're just going to be passing in the call back.

So the call back is going to get called back when the network request

completes and is parsed into the active listings.

I'm gonna call this getActiveListings.

And it's going to take in the callback of type active listings.

And what we're going to do is, oh, import callback type,

what we're going to do is just call API, and the API has our active listings.

And to call that we need to include images and shop.

And it's asking for the call back itself, which is here, so

now that, since this is public, we can call it from our main activity.

First what we need to do is set up our recycler view.

To do this we need to set a layout manager on our recycler view, and

in this case, I'm just going to use a staggered grid layout manager.

And it's going to take number of spans that we want.

For now, I'll just say one.

And it wants an orientation, which just going to say vertical to start out with.

You might want to change the span count to be based on a dimension or

integer, based on the number columns that might fit on the screen.

You can choose whatever you want.

I'm just going to go ahead and go with one for now.

And our list is going to be scrolling hor, vertically up and down.

So we've chosen vertical.

Next, we need to go ahead and set an adapter on here.

I'm going to say new listing adapter.

We need a pass and a context, which is this referring to the activity.

And we need, actually,

to use this adapter because remember this adapter is our call back.

So, let's go ahead and take this adapter object, and

get that reference before we assign it.

And then what we're going to do is first time we're running,

saved instance state will be null.

We can go ahead and just fire off the API call.

We're going to pass in the adapter.

Okay. This looks pretty great.

We need to go ahead and save state as well.

So let's override the on save instance state method,

and in on save instance state,

we need to save the data that came back from the API,

so I'm going to keep the key for the save instance state.

If savedInstanceState was null, it was the first time, we're going to go ahead, and

again, and show loading.

If it wasn't null, we need to go ahead and pull out from savedInstanceState.

The parsable object, which is our active listings and

on our adapter, we need to call success with that data.

The data is the parsable object.

Which is in fact active listings, object.

And the second value of success is the response itself.

Which we can just pass in null.

So now, if it's the first time running, we're going to go ahead and show loading,

we're going to make the call to the network, otherwise when we come back,

if we have that active listings there, we're going to just go ahead and

set it on the adapter and display our lists.

But it might be the case that we don't have any data yet, so we need to make sure

we check if there's any data to begin with in the saved instance state.

So we're gonna only do this if the saved instance state contains the key.

So if it contains that key that means it had some data.

And it, on saving some state, we're gonna go ahead and check by getting that data.

Now we need to add a method to our adapter to get the current data, so

let's go ahead and add that in here.

Public, it's gonna return back that active listings object,

getActiveListings, and we're just gonna return our active listings object.

It may or may not be null, it could be null.

So, we need to check that.

Now we have to have access to our adapter here so, let's go ahead and

move the scope of this to be just within our activity class itself.

So, if the active listings are not null, we're gonna to go ahead and

put them in our outState window.

Put parsable, going to give it the key, and the actual active listings object.

So if we have that data, it'll be passed into the bundle, the outstate.

Then come back to on create.

We're going to check if there's data.

Go ahead and display it.

If not, kick off a call to the API.

So in this case, again there was an eta, it wasn't stored in the save instance

state bundle, so again we need to show loading, and do another call to the API.

One last thing we want to do is in our adapter, we want to go ahead and

if failure does happen, we want to call back to our activity and

say we should display that error text.

So, since that's the case, we need access to that activity.

So, instead of passing in a generic context here,

let's just pass in our main activity itself.

And we'll just call this activity instead.

And we'll keep a reference to it here in the class.

And then down on success.

We're gonna go ahead and show the list by calling to our activity show the list.

Otherwise, you wanna show that failure.

So it's gonna show the error message here.

And error message we can actually retrieve from our object here.

Okay, let's go ahead and run this to see if everything is working okay,

we should get a call to the network, get a response back, display some listings.

Our app now displays listings from an API.

We use the Retrofit library to make it easy to call the API and

parse the response to the type we need.

After that, we displayed the list using Recycler view and

the staggered grid layout manager.

Finally, in our adapter, we used the Picasso library to display the images.