If we have another look at the recipes in the OkHttp documentation,

we recall that we are currently using this Synchronous Get Recipe in our code.

With some additional knowledge now about Threads, Concurrency, and Asynchronous

processing, we'll want to switch to this other recipe, the Asynchronous Get.

Notice here in the description that it will download a file on a worker thread

and get called back when the response is readable.

Let's update our code to be more like this Asynchronous model,

and then we'll talk about this call back idea.

So let's head back to Android Studio.

And main activity low, close the log.

So inside on create, we can keep a lot of our code the same.

The first difference is here, the response = call.execute.

This is the synchronous method.

We can delete that now.

So let's ignore this try catch block just for a moment, and here,

under where our call is initialized,

we want to add a new line to use the Asynchronous method, enqueue.

So call.enqueue.

Notice the parameter for this method is a callback object.

Type in new callback and hit enter to generate the callback.

Isn't auto complete great?

Well, sometimes, so this should look familiar.

We have an anonymous interclass of type callback.

It has two methods that we need to override, onFailure and onResponse.

Fortunately, good naming conventions have been used here,

making it easy to imagine what they're used for.

Let's turn back to our try-catch block.

We need to cut and paste it, but where to put it.

Since we're checking in there about a successful response,

it needs to go into the onResponse method.

Fortunately, that method is called with a response parameter already.

So we do not even need to change our code.

So we'll cut our try catch and

put it here, Into our response.

Our code is updated to make Asynchronous calls.

So let's try it out.

And another error.

Let's go into Logcat and see what it says.

So here we get a java.lang security exception permission denied,

missing internet permission.

Yes, we forgot to get permission for

our app to use the internet, that is a common mistake.

And can easily be fixed with a single permission line in AndroidManifest.xml.

So let's close down our Logcat again, go to manifest, android manifest,

and up here towards the top do uses permission.

We want Android Permission.

Internet.

And closer tag.

Great.

And let's run our app again.

Nice, no errors, and our emulator shows the default Hello World.

Let's take another look and Logcat and see our data.

And there it is, awesome, we'll talk about this

format of data called JSON in a little bit.

If you're not getting the data displayed here, you may want to debug your code and

execute it line-by-line to see what is happening.

Maybe adding additional log statements inside the on response method would help.

One common mistake is to have extra spaces, missing slashes, or

forgetting a comma when we built the URL.

So let's go back into main activity, close that down, and

take a look herein our callback.

What exactly is happening in our code here?

The on queue method executes the call, but does so by putting it into a queue.

This queue is provided by OkHttp and

executes the calls Asynchronously in the order they are added to the queue.

Since this is the only order in the queue it gets executed right away.

At that point, the call is executing in the background and

we are able to continue to execute code on the main UI thread, like normal.

We don't have any other code, but we could add another log statement down here.

Let's go ahead and do that to see the order of the log statements.

Log d tag, okay, and we'll do main UI code is running.

Hooray.

So, if this were Asynchronous code, it would process through log the response and

then log this new statement, but if we run our code now, And

look in Logcat, we see that our statement is displayed before the response.

This illustrates that the main UI thread

keeps working while the background thread is still working.

So what is a callback and how is it working?

Callbacks are very common in Java and Android development.

Asynchronous processing makes use of this, because it's the communication bridge

between a background worker thread and the main thread.

What's happening is this.

When we call the enqueue() method,

we're saying hey, call us back when you're done, here's how to do that.

We can imagine we are giving the OkHttp code a phone number to call us back on

when they're finished getting data from the web.

This callback is an object defined by the OkHttp Library.

OkHttp then says,

okay, as long as you give me a correct callback object, I'll use it.

When the call finishes in the background,

the onReponse method of this product is called.

Then the code we write inside it will be executed.

If there's an error the onFailure method would be called,

this could be an instant later or possibly a long time.

Generally, there's a limit on network connections, but

in theory, this background thread could run indefinitely.

As I mentioned, we'll talk about the JSON data in a little bit.

First though, let's make our code more robust by handling potential errors.