Android provides some convenient ways to handle JSON data.

Making it easy to work with.

With our app connected to and receiving weather data in a JSON format.

Let's take a look at how we can leverage the tools provided by Android to parse

the weather data to get the information our app will use.

We have our new data model object, CurrentWeather.

Let's put it to use in main activity.

So under our tag here, let's create a new, private,

CurrentWeather object, and we'll call it currentWeather.

Now, we'll want to set this, once we have a successful response.

So we scroll down to our onResponse, and

inside our if statement here where our response is successful.

Let's set currentWeather.

And we'll set it to a new method that we'll define here in a moment.

We'll call it getCurrentDetails.

We'll want to pass in JSON data.

We can use the response.body that we have up here in our tag.

But let's actually refactor that into a variable, and use it in both places.

String.jsonData.

Now we can pass in jsonData.

Okay, now let's use the quick fix provided by Android Studio we put there.

Alt + Enter, Create method.

And again we want that inactivity not in our onCreate anonymous callback.

Next, we're going to work with a special class called JSONObject.

This class is able to hold any object represented in JSON format, and

provides a few different methods to access the properties inside the JSON data.

The JSONObject class has a constructor that lets us pass in a string

of jsonData to create the new JSONObject.

Fortunately, that's just what we have as a parameter.

Let's create a new JSONObject inside our new method.

JSONObject, plot forecast cuz that's what we're getting back.

We see that we have an error here.

We hover over it.

We see that it is an unhandled exception.

This is similar to the IOException we previously seen.

But this is a JSONException.

Just like we've done before, we can use the quick fix to add a dry catch.

Now, while this works, this isn't ideal.

It would be better if we could have the exception handle, or

the getCurrentDetails method is called.

Up here where the IOException is being caught.

It would be great if we could get this new exception to bubble up, and

be caught up here.

We can do that with a throws keyword.

Back here in getCurrentDetails, let's undo our try/catch block,

and after our method signature before the curly brace, we wanna type throws.

And then we need the specific type of exception.

In this case, it is a JSONException This

moves the responsibility of exception handling from this line here in

getCurrentDetails to up here where the method is called.

We see now in onResponse where getCurrentDetails is called,

it has an error.

Since we're already inside a try block, we can catch the JSONException down here.

We'll catch the JSONException.

And we'll add a log statement for it.

Now our code is a bit more organized since our exceptions are all being handled in

one place.

With that exception handled, we can continue to set our JSON object.

Let's take a quick look at the Android documentation on JSON object.

Let's see what types of data we can get.

We see that this class has several methods that allow to get different types of data.

Strings, ints, booleans, JSON arrays.

Even other JSON objects.

We'll see some of these methods used in other projects, as well.

Let's take another look at our data as a guide for

how we should parse our JSON object.

The JSON object forecast that we just created in our code

corresponds to this root object up here.

Remember our root object starts with a first opening brace.

We're passing latitude and longitude in as parameters to the API call.

So we don't need to worry about those.

Let's use this timezone field as an example to start.

timezone in all lower case is the key we want to get.

The value is enclosed in double quotes.

That tells us that it is a string value.

Let's go back to our getCurrentDetails method.

So we can access this timezone, and write it to the log.

So String_ timezone.

We're gonna get forecast.getString.

We need to pass in the key we want.

We say that it was timezone in all lower case.

Then we want to log that.

So Log.i, TAG say From JSON

plus our timezone.

Cool, we should test this out just to make sure we are,

in fact, getting what we're expecting.

This is important, especially when trying to parse through complex data.

Building things one step at a time, and

verifying them along the way is a great habit to get into.

Otherwise, you can end up with a lot of code that can be broken in multiple

places.

Now, before we run it,

we have another area here because we aren't returning anything.

Let's just return null for now.

Run our app.

And checking here in the Logcat.

Here's our parsed data from JSON, America/Los_Angeles.

It's working!

That's great!

Let's take a quick break, and

we'll get our current weather all set up when we come back.