The data model for our app is coming along quite nicely.

We've accomplished a lot those far, with parsing

the days on formatted weather data, and getting it into our current weather model.

However, if you recall from our time value, it was a bit unwieldly.

Lets take another look at the documentation for our API,

and see what we can discover.

If we go back to the dark sky documentation, and

click on the response format link, We see a list of the various object,

and their properties that are returned from the API call.

We're working in the currently object.

So let's click on this data point link here for additional information.

If we scroll down a bit, we see the time property.

It says that this is the Unix time where this data point begins.

What is UNIX time though?

UNIX time is a system for describing time, you find is the number of seconds

that have elapsed since coordinated universal time, UTC.

UTC started on Thursday, January 1st, 1970.

You may also hear this referred to, as the UNIX Epoch.

I know.

Leave it to developers to represent time in a crazy fashion.

But, this is a very standard way of handling time on UNIX systems.

Unfortunately, there are several built-in methods to handle this format.

Our mock-up calls for the time to be displayed in an easily readable format.

Right now however, our time is in a huge number of seconds.

We'll need to convert that into a more human readable format, and

put that time string into a text view.

Notice too that we're just wanting the time portion of the time since

the UNIX Epoch, we're not concerned about the date.

Let's add a new method to the current weather class called, git formatted time.

We can use the simple date format class to help us out.

Looking through the documentation for a simple date format, we see that it can

take in date and time values in different formats, including UNIX time.

It can then convert them into low-cal specific time.

This is exactly what we're looking to do.

The way this works, is that we create and configure a formatter object.

Then use it to format a date value.

There's a list here of all the different format symbols we can use.

Recover more mock-up, if we want the time to be in the format of hours

without a leading zero if it's a single digit.

Then minutes, and then AM or PM.

Let's head back to current weather, and create our formatter, and

set our time value.

So back here in current weather,

let's add a git formatted time method, under git time.

Public, will return a string called, getFormattedTime.

Inside here, we'll put SimpleDate format to use and build our formatter.

SimpleDate format Call it formatter.

Be a new SimpleDateFormat, hours without a leading zero, minutes,

including that leading zero, and then a, which will give us our AM or PM.

We're getting the time value from the forecast, from the location we specified.

In our case, that's Alcatraz Island,

which resides in the San Francisco Bay of California, in the United States.

And, it's in the Pacific Time Zone.

Therefore, we need to set the time appropriately with the time zone in mind.

So we can do formatter, SetTimeZone.

For our perimeter in here, we can use a helper from the java time zone class.

TimeZone, getTimeZone, in here, we need a time zone code as a string.

Seems like we've seen that somewhere before.

Let's look at getCurrentDetails over in main activity.

There it is.

We're logging it here in getCurrentDetails.

Let's add it to our data model, so we can use it.

Make it a private, String, TimeZone.

Now back in main activity,

we can set our timezone using the timezone variable we already have.

CurrentWeather, setTimeZone,

Passing time zone.

And it looks like we need to go back, and generate our getter and setter for that.

So Code, Generate, Getter and

Setter for timezone, great.

No more error there, if we go back to current weather.

And we can use that timezone, In here.

Our formatter is ready.

We just need to return it.

Return, formatter.format.

Now here's the tricky part.

Working with dates can be a challenge, it can require a lot of trial and

error in readings or documentation.

We need to pass in a Java Date object here, so

let's look at the Date documentation.

We look here in the Constructor Summary,

there's a constructor here that takes a time value as a long.

Nice.

That's what we're already have.

Well, wait a second.

It says here that it needs to be in milliseconds.

Our time value is currently in seconds.

So we need to make that conversion first.

This can be super frustrating, and cause lots of headaches, if you don't

realize that the time needs to be in milliseconds, and you pass in seconds.

Fortunately, it's an easy fix.

We simply need to multiply our seconds by 1,000,

since there are 1,000 milliseconds in a second.

So we'll do Date dateTime, do our import.

We want the java.util.

Date (time * 1000),

I forgot an equal sign,

that would be good to have.

Now we can pass this into our time string formatter.

All right, let's test this out by calling this new method, and

logging it in main activity in the getCurrentDetails method.

So main activity, getCurrentDetails, down here.

Log.d, our TAG, currentWeather.getFormattedTime.

And let's remove this breakpoint, since we won't be using a debugger at the moment.

And we'll run our app.

And look in the Logcat.

And there it is, our formatted time, very cool, this will be ready for us,

when we get to working on the user interface.