[MUSIC]

Hi, my name is Jamie Huson and I'm an Android Developer at Etsy.

In this workshop, we're going to integrate the Retrofit library from Square into

an app to show how easy working with an API can be.

Retrofit makes performing HTTP calls easy by having a concise,

easy to read syntax, straightforward integration to a project, and support for

the Android Freddie model as a default.

Let's break down how it does this.

Retrofit consists of four parts.

An interface that declares the end points,

their HTTP types, callback types, and parameters.

The methods are annotated making it easy to configure an endpoint without

much code at all.

Here's an example of a basic HTTP get call.

Next, is the adapter.

The adapter transforms your interface into an object instance you can work with.

An adapter can be configured with additional information about your

HTTP stack.

A converter will be used to convert the returned binary data

into a java object you can easily use.

Finally, a call and callback mechanism, to have fine grained control over when and

how requests are executed.

In this app, we're going to connect to the image or API, we'll be able to anonymously

upload images or sign in for a user and upload images to their account.

I've supplied starter project files for you, you can import these to

Android Studio or create your own new project and drop the files in yourself.

Here I've got the start files open in a project.

So let's check out what I gave you.

First thing we're gonna look at is our build.gradle file for our app,

let's go ahead and open that.

And what you'll see here is that near the bottom, I've added some dependencies for

us already and that includes the most important one, retrofit,

what we're gonna be learning today.

And also the second part of that is the retrofit converter using gson.

So it's important that your code matches exactly what I'm doing here, so

make sure you use the same version as me.

You can upgrade to a more recent version but

there may be changes in how the code is written.

You can also see if supplied the main activity,

base application an adapter for a list.

This classical o op util, we'll go back to that later, and some model classes here.

Next we need to look at the documentation for

the API we're connecting to, in this case imager.

Let's go ahead and go to the browser and go to their documentation site for

their API, it's api.imgur.com.

And if you don't have an account with a Imgur, go ahead and create one.

And then, what we're going to do is we're going to go up to our account,

in the upper right, and go to settings.

What we're going to look at is applications.

So I've created an application here if you haven't created one, go ahead and

create one now.

And what you'll see is that it has a name of called mine Retrofit Test,

you can call it whatever you want and a client ID, that's really important we're

gonna need that we don't need the secret but we do need this thing called redirect.

So you can see here if I click edit what mine is,

it's https://treehouseworkshop:88.

:88 is a port, so enter yours something like this.

If you're not sure, just put exactly what you see here on the screen.

Okay, so once we have all those applications set up with the API

what we're going to do is we need to authorize our app to work for

users, that will allow us to upload images to their account.

So to do this what we're going to do is use something called oauth and

this has a flow to it.

And it's described here in the documentation in detail under

authentication and oauth 2.0 you can read more about that but

the just of it is this we're gonna direct the user to a URL in the browser and

in that URL we're going to put our client ID.

Then the user is going to sign in and the browser will redirect to another URL,

that's our redirect URL we just supplied in the application settings.

So our apps can intercept that URL and direct users back into our out.

And then we're gonna parse out

some really important information on how to connect to image or API.

The most important one is the access token that it provides for us.

So to begin, let's go ahead and create a place in our code base to store all these

constants that we need to know about for connecting to this API,

all this information, is found here in the API documentation, and so

if you have any questions you can come back, read through this,

and look it up they're switching to the code base.

Okay so the first thing we wanna do is we wanna create a place to store what URL

we're gonna be connecting to.

So in our API let's go ahead and create a new Java class let me call it

Imager and it's actually not going to be just a class I want to be an interface.

And in here, we're going to go and

store the basic information about connecting to images API..

It's pretty string we'll call it an imgur or base URL,

and this is the base your ID, connect to their API.

Okay, the next thing we need to do is we need to store that client ID,

we're going to use that to connect.

So you wanna go ahead and go to the web site again, go

to your account settings, go to your applications, and copy in that ID.

And then we're going

to create this URL that

has our client ID in it, and this is what that URL looks like.

Again, it's documented in the documentation,

you can read about it there.

This is what it looks like, I'm gonna call it AUTHORIZATION_URL.

And it looks like this.

API, and then oauth2, authorize and

one of the parameters we need

to include is the client ID.

So, it's client_id and then I'm just going to append client ID to it.

And then this ends with a final type,

which is what we want to get back from this.

What we want to get back is a token, so let's go ahead and tell it that.

Response type is the parameter, we just want to say, we want a token back.

Okay, finally let's go ahead and store that redirect URL.

Next, we need to add in something to our manifest and this is what's gonna allow

us to redirect the user back to our app once they've signed in and

gone through the authorization process on the imagur website.

It's going to open up our manifest and

scroll down, and you can see this block is really important.

I've already put it in there for you but

it's important that you know this is in there.

So what we're saying is that if we're going to VIEW this URL, starts with https,

treehouseworkshop, the port is 88, then we want to go back into our app.

So if you don't have this in there this isn't going to work so

make sure that this is included in your project.

If you use my starter files it's already in there.

Okay, now let's place all the information we get back from the API

into a shared preference object.

So the API is gonna give us back this token, and we want to be able to store

that so that we can make requests every time the user starts the app.

So let's go out and put in a shared preference.

And I've started that already using this oauth2 class, so let's open that up.

We can see here I have added some todos for you.

Need to put the constants in the top, let's go ahead and

start doing that right here.

So again these represent all the data we're going to get back

from the imager API, we're gonna get back an access token.

Gonna get back a value called expires_in,

this tells us how many milliseconds our access token is valid for

before it expires and we need to authorize the app again.

We're gonna get the type or the token type specifically.

And we're gonna get something called the refresh token.

This is what you use once your token has expired to get a new token.

And finally something that's going to get

passed to us is the username of the account that we're accessing.

Okay, so what you'll see is that I'm keeping a singleton

of the shared preference in this class.

And I wrote a little TODO here, in case you're not using my starter files.

In your base application, make sure you call init here,

this creates a new instance.

So there are some getters and setters for storing data into the shared preference.

And the last thing we need to do here is we need to complete the logic for

this helper called isAuthorized.

So isAuthorized is going to tell us do we have a valid token or not, so

to compute whether we have a valid token, what we need to do is return.

If we have an access token at all, so that should be not null.

And we want to make sure that the expires in value is still valid,

so let's call getLong and get the EXPIRES_IN value.

And make sure that that's less than the current time on the system.

So if both these cases are true, then we have a valid token and we're authorized.

That's good for now, when you come back we'll authenticate our app for the user.

Now that we know about how Retrofit works, let's start writing our app.