Now that we know how the API works, let's use Retrofit to interact with it.

Retrofit uses interfaces to represent the API we are connecting to.

Let's start by creating a new Interface.

Here in my API package, I'm just going to create a new Java Class and

the type is going to be Interface.

I'm just gonna call it Api.

Next, we're going to add a method for each API call.

The API we're using returns back active listings from Etsy, so

I'm gonna call mine activeListings.

Now, Retrofit can be a little overwhelming when you're first learning how to use it,

but it has an elegant syntax that helps us understand what it's doing.

And, it does a lot of work for us, with only a little bit of code.

Retro fit uses annotations to tell it where the URI is and

what HTTP protocol to use.

From the documentation earlier, we know our protocol is get and

the URI is slash listing slash active.

Let's go ahead and annotate our method using the available retro fit annotations.

It's gonna ask us to import those as we would any other class or object type.

And, we also need to include a string that represents the URI,

which is /listings/active.

To include URL parameters,

we can include those as optional parameters in the active listings method.

I'm gonna annotate mine as Query, and I'm gonna give it a name.

The name is includes.

So, the includes was the image and

shop data that was coming through the API with our listings call.

We need to make sure we import those as well.

And, we need to give this a name as a variable.

Just gonna call it includes.

Finally, we need to include a callback.

Notice that the type of this method is void.

That means it's going to callback immediately once you call it.

But, we need to include a callback which when the response happens and

completes, we'll get a callback on the main UI thread.

Retrofit includes a class called Callback.

The callback mechanism is just like what we used in the weather app using OkHttp in

an earlier course.

This callback is gonna be typed to the Java class that the network response will

be converted into by Retrofit.

This means that Retrofit automatically parses the network response, and

creates an object of the type you want, with all the data set on it.

All you have to do is give it the class that corresponds to

the response from the API.

In this case, we wanna go ahead and use the ActiveListings class.

Again, we wanna go ahead and import this.

Great.

Our API is all set up now.

Next, we're going to add to our Etsy class.

We're gonna add a method to retrieve back an instance of the API interface we

just built.

We're gonna open the Etsy class, let's go ahead and add a method in here.

Private, static.

And, it's gonna return back the API we just built.

And, I'm gonna call it getApi.

We're going to use the included RestAdapter class

that's a part of Retrofit.

RestAdapter has a builder that's a part of it,

so we're gonna say new RestAdapter.Builder, and

with the builder pattern we can easily configure it with any options we need.

The first we're gonna do is set the end point.

So, from the Etsy documentation,

we know the endpoint is https://openapi.etsy.com/v2.

Once we set the end point, we can just call .build and then .create.

And, when you call .create what you're gonna do

is pass in the interface that you wanted to create an object from.

So we're gonna pass in the Api class.

Now, this going to return back an instance of Api with the end point set to it.

One thing we might've noticed is that we haven't set up the API

key anywhere in the request.

We can do this by adding in a request interceptor which allows us to

append a parameter at the end of the request after it's initially created, so

let's go ahead and make a method that will do this.

I'm going to create another method and

it's going to return back a request interceptor.

Just gonna call it getInterceptor.

And, it's gonna return back a new request interceptor.

What I'm gonna do is just add in the parameter that I need,

my API key with every request.

So, I'm gonna take the request and just say addEncodedQueryParameter.

And, the name of it is api key.

And, we started here in this value of capital API KEY.

We just append it there.

Finally, back in our builder,

we can call into setRequestInterceptor and call getInterceptor.