Our next step is to update our data model.

In current weather, we need to create two different constructors for our class.

Fortunately, Android Studio can generate those for us.

Go to Code > Generate > Constructor.

As I mentioned, we need two different constructors in our class.

So we'll generate the first one that will accept no arguments.

We just need to click on Select None.

Give some space.

We'll generate our second one.

Instructor, this one, we'll select all the variables.

And let's clean this up a little bit.

The basic constructor is used in main activity

in our get current details method.

The second constructor will be used when we bind our data.

And these dual constructors are a great example

of constructor overloading in Java.

For more information about this, check the teachers notes.

Alright, with our model updated,

let's take another look at the data binding documentation.

If we look here at Binding Data, we see that the easiest means for

creating the bindings is to do it while inflating.

I'm all about doing things the easiest way possible.

So let's follow this example.

So we need to go back into onCreate and adjust our set content view statement.

Back into MainActivity, so here we're at SetContentView.

ActivityMainBinding, Binding, do our imports.

It's gonna be a DataBindingUtil,

convert context, MainActivity.this.

Let's drop that down to a new line.

The documentation says that we need to bind our data to our new binding variable.

Well, we don't have any data at this point in onCreate.

We do, however, have it down in onResponse,

where we're making a call to getCurrentDetails.

So let's bind our data at that point.

So down here in onResponse, We'll

make a new CurrentWeather, Object, we'll call it displayWeather.

Will be new CurrentWeather.

Here's where we'll use our new constructor.

We'll pass in the information from our CurrentWeather variable as called for

in the constructor.

GetIcon.

GetTime.

GetTemperature.

GetHumidity.

GetPrecipChance.

Get our summary.

And get our time zone.

Fantastic, now we need to use this new displayWeather with our binding

variable to bind our data.

We can do binding.setWeather, and we'll pass in displayWeather.

Since we're using binding from within an inter class,

we need to make sure that it's declared final.

And it is, thank you Android Studio.

Since we already have one data point, our summary, set up in our layout,

let's run this and make sure our data is coming through.

And it's changed in our app, and if we look in Logcat and our JSON data.

It's the same there.

That's awesome.

Let's head over to our activity main XML file and update the rest of our fields.

Before we get started on this process,

let's think a little bit about what our text field is wanting.

It's expecting string values, so we're going to have to make a decision.

Do we want to alter our model and store data as strings?

Or do we want to convert them to strings here in the XML?

I think it makes more sense to keep our data in its native state in our model.

With that in mind, let's look at our temperature value here.

We want to update this static value to our data value.

We'll do @ with our curly braces.

We wanna convert it to a string and get the value of,

weather.tempeture.

Next up is our time value.

Here we want to use our formatted time and

add it into the middle of our statement of at such and such a time it will be.

To concatenate text inside an Android text value,

we need to use the grave accent character instead of quotes.

That character is found above the Tab key on most keyboards.

Inside our time value then, our string will look like this.

Grave accent At space and we'll concatenate,

String.valueOf.

Weather.formattedTime, and then the rest of our string characters.

It will be and another grave accent.

Let's go down to humidity.

Humidity value, String,

value of, weather.humidity.

And for precipitation,

we need to concatenate that percent sign in there as well.

Add in a grave accent with a percent.

Let's run it again and see how that looks.

Well, there's our data, but our temperature has a decimal point in there,

and our precipitation value is a decimal.

I think just having the whole number is better, and

it fits with our design markups also.

Again, it's decision time for how we handle that.

We can do it in our model or in our XML.

We can certainly handle it in either place but changing it in the XML allows for

more flexibility if we decide to expand our app to another activity and

need to use the data elsewhere.

Therefore, let's update the temperature and precipitation values in there.

We can use the round method from Java's Math class to round our values.

For temperature, then, we can go back up here to temperature.

We'll do Math.round, weather.Temperature.

And for precipitation,

we want to multiply it by 100 to make the decimal into a percentage as well.

Math.round.

Let's run it again.

Very nice, our text data is coming through and updating our view.

This is looking great.

We lost all of our default text though, in this process,

making it a bit of a challenge in our design pane.

Let's add the default values back in, not only for ourselves during the development

process, but also so our users don't have to stare at a blank screen.

So we'll come here, Default, 50%.

For humidity, Default,

0.88.

Default here will be at 5 o'clock PM, it will be.

For temperature, we'll do a default, 100.

And we'll add one for the summary as well.

Default is stormy with a chance of meatballs.

Remember to use the grave accent character there to be able to have spaces in our

strings.

This is looking nice, but what about that weather icon?

Let's see about updating that next.