Welcome back, we added the functionality to authorize the user and

allow our app to act on behalf of them.

So next we need to add the functionality to connect to the imager api and

get the user's currently uploaded images.

And this is where we're start leveraging retrofit.

So to connect to an api using retrofit, we want to create an interface.

And that interface is going to describe the endpoints we're connecting to.

So here I already have our imager interface, and

we're going to start adding to it.

So in here I'm actually gonna make sub-interfaces within this one and

that's because some of these endpoints we connect to are gonna require

authentication, some of them aren't, so we want to distinguish between those two.

So here I'm gonna say interface and I'm just gonna call it auth

because these are gonna be the endpoints we connect to that require authentication.

And next we wanna go ahead and add the method for

getting the users uploaded pictures.

Here's what that looks like.

First we can annotate the type that this is gonna be.

It's going to be an HTTP GET call.

So we annotate get.

Notice it's prompting us to import here.

We're gonna go ahead and do that.

Then we're going to add in the end point that we connect to.

And this is found in the documentation on the Imgur API website.

The version is three of their API.

You want to connect to the account.

And we're going to put in the user name.

Get the images for that account.

And optionally page through various pages

of images if they have a lot of images uploaded there's gonna be pages of them.

The method actually looks like this has a name.

We're gonna call images and

text we fill in those path variables user name and page.

We're going to supply an annotated path parameter here,

and we just want that to match the names that we gave them in the URL.

And this is going to be a string.

The second one Is the page number.

That's gonna be an int.

Okay, but we need to make sure that we import these as well.

And finally we need to add the return type.

So on retrofit the return type is always a call.

You can see here that it's parameterized and

the type we're expecting to get back is something called BassicArrayList=Image.

And we're gonna wanna use the image class that's in the model that I've supplied.

Let's go ahead and take a look at what basic actually is.

So if we look here in our model we can see that basic is a really simple class.

It has a status code, and a bullion indicating whether this call is

successful, and then it has some data associated with it and

this is parameterized as well so the type of data is whatever you supply to it.

In this case, I know that I want to get back an ArrayList of images.

And we can look at the image class.

It's also pretty straightforward.

It's just all the metadata that each image has when it's returned back from

the imager API So looking back here, we can see we have a complete API call now.

Okay since this is an interface, it's not an actual object we can work with.

We need something to create an object out of this interface declaration.

And that is something that we usually call a service.

You can call it anything you want.

But typically will create a class called service.

And we're going to use this to create instances of our API that we can use.

So it's going create a new class and our API.

We'll call it service.

And what we want to do here is how to method that returns back

an instance of our.

API interface that we just created.

So let's go ahead and create a new method and static, and

it's going to turn back the type that we just created.

And we'll call it getAuthedApi.

And the nice thing

about retrofit is that it has really nice builder classes built right into it.

So here we can say return new retrofit.builder.

Let's go ahead and import that.

And the first thing I wanna supply is the base URL and

we stored that earlier in our image or a class.

We wanna add a converter factory.

So this is what's actually used to take the binary data and

convert it into some object type that we can actually use.

Those are the models, image that we have in our model package.

So the one we included in our dependencies,

if your member earlier, is the JSON one.

JSON has JsonConverterFactory.create.

And this creates an instance of this converter for us.

Finally we call, build.

And then we're gonna call create.

And in create, what we're going to do is pass in what we want to create.

Which is an instance of our Imgur.Auth.class.

So this is gonna to return back an instance of our Imgur.Auth.class.

Now there's one thing we do need to add here, and that is because

in the documentation found on the website it says, for every request, if

we're authorized by the user, we need to include the access token in that request.

And the way we do that is we add a header to that request.

So the way we're gonna do that, it's pretty easy, pretty straightforward.

First we're gonna get our HTTP client.

It's the OK HTTP client.

And we're going to supply a custom OK HTTP client.

We're gonna use the builder and with the builder are gonna say add interceptor.

And here's what this is gonna do.

Every single call that goes through this instance of OkHttpClient will

be intercepted by this piece of code we're about to write.

And so for every single request that comes in, we're just going to take that and

append a new header with our access token and let it proceed.

So create a new interceptor.

And you can see here the call that happens is called intercept.

And when it calls intercept has this chain.

So there can be multiple interceptors.

Happening at different levels of the request and so

what we're going to do is we're going to call chain.request and

this is going to give us back the current request.

I wanna call it authed let's import this and

the request is now going to be added to.

And to do that, I can use a newBuilder.

And with newBuilder, it allows me to build on to the existing request.

So I'm gonna say, newBuilder addHeader.

And the header is authorization.

And the format looks like this, bare space.

And we want to add in our token.

So I'm going to call get access to it.

Finally We can build this, and

this is gonna return back a new request that is off.

That is it has an authorization header we've added to it.

Finally from this we have to return back a response, and

that is done by saying return chain.proceed.

And this will proceed to send our new request

on to the next level in the network request.

And here, instead of ending it, we're going to call build,

cuz we were working with the OkHttpBuilder here.

So call build here.

That returns back the actual client.

And one final thing is we need to supply this client in our retrofit builder so

that it's used every time we make a call here.

So here, we're just gonna call client, and supply it.

So this is gonna complete our Service class and the getAuth API method,

which will return back an instance of the interface Imgur.auth.

Okay, so we've written some code.

Uses OK HTTP client, it uses retrofit builders.

So, you might be wondering what's the difference between all this?

What's retrofit, what isn't?

Let's go ahead to talk about the differences between HTTP,

OK HTTP and retrofit.

So, http, it's a standard protocol used by all web sites to

deliver content between different clients.

So it has things like the type.

Here we have to get it's using HTTP 2.0 and it has the host this is

the API we're connecting to and that typically has a whole bunch of headers.

So these have a lot of different information used by clients to know

what data is coming over the wire.

Then there's going to be some response.

That might be a 200, that means it's okay.

That's a standard value.

Again, this is just a protocol being used, in addition to this the response might

have a number of headers as well, just like the request had.

The response will have additional headers.

And finally, the response is going to have the actual data

that it's responding with, so in this case, some Json.

And we can see here.

It has an id, a title, a description.

This is just an example.

Typically a response is much longer, has much more data involved.

So that's HTTP.

So what is oKHTTP?

OkHttp Is an HTTP stack that allows us to make HTTP calls using HTTP easily.

We can create a URL like this by just making a string.

We can create a new client and then create a new request using a builder.

Here I call get.

It's a get request, supply the URL.

I can add headers and call build to build a request.

And then I can say newCall.

And that's gonna give me back this call object.

And then I would do something like this.

I would say call.enqueue.

This is going to enqueue this call in a threading pool.

So it's going to execute off the main u.i.

thread.

And i'm going to get a callback so i supplied a callback here.

You can see I have a response and a failure.

So if i get it back it's a two hundred that means okay.

I'll get my response call.

If something happens and this fails, I'm gonna get it an on failure call.

So that's OkHTTP,

it wraps up it’s to be a protocol in some nice builders and

easiest classes, then there's retrofit.

Retrofit adds another level of easy syntax to use on top of OkHTTP.

So we can see here, instead of having to type .get, we can actually annotate

the URL and dynamic path variables and the type, all in one go.

We can also easily tell it what type of data we expect to get back and

it does the converting, using that converter factory we supply.

And then we can just create a simple, small piece of code using the retrofit

builder to tell it, all right what is the API URL we're connecting to?

Do we need to supply a custom client?

Which we did.

And it creates an instance of that class for us.

So it takes that interface, creates an instance object that we can easily use.

Finally it does return back a call the same type of call that HTTP has and

again, we can enqueue it.

But the difference here is that we can use this nice,

static method we built in our service class to do something like this.

We can say Service.getAuthedApi.images, enqueue, and

just put our callback right there.

So this is something that we're gonna add to our activity to actually call this.

And then the callback is gonna happen in our activity so

we can display the images that come back in the UI.

And again you'll notice we get the onResponse, and we get the failure.

So we know what's happening and we can respond accordingly in our UI.

Here we're back in our main activity and now we want to actually add the call to

the API that we created in our Imgur API interface.

So here we can see that in on create we check if are authorized and if so

we call this show account images so let's go and go to that definition.

You can see here that first we're just going to show the images container and

hide the sign in an anonymous upload buttons.

And the first thing we need to do here is our to do which is to actually

make this call.

So let's go ahead and we'll add a call to another method called fetchAccountImages.

And then let's go down and define that.

Okay, so we're gonna use our service class that we created before.

Service.getAuthedApi.images.

And the first thing we need to supply is that user name so let's go ahead and

use their off util to retrieve that back.

And the second thing is the page number.

For now let's just go ahead and use page zero.

That's going to be a very first page.

So this is going to return back a hold command.

Hover over here, it's gonna return back our call.

And then we want to enqueue our call and provide the callback.

So we'll say new callback and go ahead and do what it suggests us to do,

which is provide an implementation with the type correct.

It's gonna return back our array list of images.

So, onResponse is gonna get called as long as the HTTP call succeeded,

went through and connected to the API and came back.

So, it may come back and it failed in some way, according to the API.

The request didn't fail coming back,

but the API maybe didn't like our request in some way.

So the first thing we want to do is just check that our response.code

equals a known value which is OK.

That's the two hundred value.

And so as long as it's OK we know that We got data back.

That's what we wanted.

So if we do have data back, what we want to swap that in for

the adapter that's set on the recycler view in this activity.

So I've already set that up in the starter files.

So first thing I'm gonna do is just cast to the type ImageAdapter and

get our adapter from the recycler view.

And then I'm gonna call the method on it swap.

And I want to swap in the new data.

Notice that the data is already in the type I need it.

That's because retrofit converts the binary data

into the type that I need using the converter.

So here I can just say response.body().data.

That's gonna swap out these new images into a recycler review.

Now if something went wrong if there was something else that was a problem,

let's go ahead and indicate that in some way.

I'm going to make a little snack bar.

You probably wanna have some sort of prompt or make sure we go into

a state to allow the user to retry this or maybe retry yourself a few times.

But for now I'm just going to go ahead and supply a snack bar to just indicate

visually in the UI if something went wrong.

I'm gonna say Failed and provide a little sad face.

Finally, don't forget to call show and

I'm going to do the same thing if a failure case happens.

So, a failure would call back to onFailure,

if the call was unable to complete in some way.

So if the call does complete in some fashion, maybe the code's wrong or

we requested something incorrectly.

But it does complete.

It'll come back to onResponse.

If it fails in some way

trying to transmit the data over the wire it's gonna come back to onFailure.

Now finally it's important to note that when we call enqueue and

we provide this callback, this is going to happen on the main UI thread.

The call itself will happen on another thread, which is what we want.

But we can interact here, for instance,

with our adapter because we are on the UI thread.

One more quick thing we're gonna do is just add in another snack bar to tell us

that we're getting the user's images.

So we'll say Getting Images for Account and

that'll just provide a nice UI so we can know when this request starts.

Ok let's go and run this and see this in action.

What we should see is that when we run it we're not authorized.

We're going to need to authorize our app, get a call back into our app, and

then make this call to fetch image accounts.

And when we come back up here what we'll seen on resume is that

If it is authorize show account images should be called.

And that will in turn call fetch account images and

we should get those images displayed back to us.

So let's go to run this.

And run this on our device switch over to our device now.

And our app just started.

First thing we'll see is we have the sign in button.

The upload anonymous image button, we'll get back to that later.

First thing we want to do is we want to sign in and

authorized user and authenticate our app for the user.

Go ahead and click sign in.

Remember this can take us to the image or API website where we need to log in.

So here log in with your account and click allow.

I'm gonna go ahead and log in with mine now.

Okay, so once user signs in it's gonna open this prompt with the url

that's coming back to our apps so we wanna go ahead and use our Retrofit workshop.

And you can either say just once or always.

For me i'm just gonna say always.

Here you can see it said we are getting images for this account.

And lo and behold the images appeared.

So our API call succeeded.

And we got the images.

So this looks pretty great.

In the next video, we're going to go ahead and fill out the functionality for

this bottom Upload Image button.