We left off with the general knowledge of the OkHttp API.

We've been looking at the project page on GitHub.

But let's turn our attention to the project's website shown here.

I've included links for this in the Teachers Notes as well.

The project's site provides additional information about the library and

has some examples.

One thing to note that is shown here is the minimum requirements for using OkHttp.

We need to be using Android 2.3 and Java 1.7.

There are newer versions of both of these at this point, but

it is something to check and consider.

We're using Gradle for our project, and

if we look here in the download section, We see a Gradle statement we can use.

It's also listed over in their GitHub repository.

So let's copy this line, and head back to Android Studio.

In the project pane we need to expand Gradle scripts,

and the build.gradle file for our app.

This one here, we don't want the Stormy project file, we want the app file.

Android Studio has a main module,

typically called app, it has application-specific code.

This is the file in which we can paste our line of code from OkHttp.

Looking in here, though, where should It go?

This Gradle file doesn't look at all like Java code, right?

Well, it isn't.

Gradle is an automated build system used in Android development, and elsewhere.

It allows us to configure a few things, and in exchange, it does a lot of work for

us automatically behind the scenes.

It's a huge time saver, and once it is setup for

a specific project, we don't have to do much else.

Another productivity enhancement, very cool.

When using an outside resource, such as OkHttp,

our Stormy app depends on that library, Gradle excels at managing dependencies.

And hey, look at this,

there is a section in our build.gradle file called dependencies.

That's where we'll paste our line of code from OkHttp.

So we can go right down here under this last implementation,

and we'll paste in our line from OkHttp.

Let's quickly talk about this build file.

This Android section up here at the top provides settings for

things like the SDK version, and our default configuration.

The dependencies section, where we just added our code,

tells Gradle about external dependencies we'd like it to manage.

We can see that there is a file tree where Gradle watches for Java archive files, or

JAR files, in the Libs directory.

Some third-party libraries are still used via JAR files, and

Gradle can keep track of those.

There are some additional dependencies in here relating to testing and

compatibility features.

The format, though, is the same.

In our case, the com.squareup.okhttp3 tells Gradle where to find the file,

that OkHttp is the library to get, and that 3.10.0 is the version to use.

When a new version comes out, you can come back here to this build.gradle file,

update the version number and synchronize the new changes.

Which reminds me, anytime we make changes in this file, we need to sync the changes.

This allows Gradle to update the project, and

get any additional files our project may need.

You'll notice that Android Studio displays a warning up here about this as well.

We can either click the Sync Now link, Or

click on this button to perform a project sync.

After Gradle all goes and rebuilds the project,

which depending on your system and network can take a few moments,

we see a message that Gradle build finished, down here at the bottom.

Once we see that message, we're all set.

If, however,

you get an error, try using your Google skills to find out what happened.

Check the Teachers Notes to see if there are any updates, or

ask questions in the Treehouse forum.

With OkHttp installed and all set to go, we're ready to use it.

We head back to the OkHttp website here, We can look for the examples.

There's also other links to resources on this page as well,

such us Javadocs, there Wiki, and StackOverflow.

The OkHttp Wiki has some decent usage examples, and

I encourage you to have a look around before we come back together and

make our first http get request from Stormy.