Now that we've successfully stored our instance state

all that's left is to retrieve our bundle when the activity is recreated and

use that bundle to setup the screen.

We had a special method to save the state of the activity, and

as you might have guessed, we also have another to restore the state.

It's called on restore instant state.

We can retrieve our bundle by using the on restore instant state method, or

by using the bundle we get from the on create method.

The only difference is that on the restore instant state

won't be hauled with a nulled bundle and on create will.

So if you use the bundle with on create just be sure to check that it isn't null.

Other than that, it typically doesn't matter which method we use.

Let's go with onRestoreInstanceState,

using the same Ctrl+O shortcut as last time.

And hit Enter to select it.

Now that we have access to our saved instance state bundle, we need to

extract the fact and color values and store them in the appropriate fields.

Similar to the putString and putInt methods we used in onSave instance state,

we can use the getString and getInt methods here

to retrieve our values from the bundle, and put them into the appropriate fields.

We just need to provided the key as an argument.

We can also specify a default value in case a key isn't found,

by passing in a second argument, but we don't need to do that here.

Let's type those out.

Set mFact =_savedInstanceState.getString.

And then we'll provide the KEY of

KEY_FACT.

And we'll assign to mColor

SavedInstanceState.getInt and KEY_COLOR.

Looks good.

It's not enough to just populate the fields.

We also need to update our views to use these values.

We can use these same methods as the on click listener below

to set their properties.

I'll just copy them from the on click listener up into on restore instance state

to keep things simple.

We'll need to set the text of our fact, as well as the background

color of the application and the text color of the button.

Now that we've updated our views to use the values passed in by

the saved instance state bundle, we should be all set, right?

There's only one way to find out.

Let's test the app.

I've already got my emulator up and running.

So, all I need to do is hit the play button.

Oh, and in case you haven't seen it yet,

we have a workshop on getting the most out of your Android emulator.

Check the teachers notes for a link.

Here's the app.

I'm going to click through a couple fun facts.

And then rotate the emulator by using function key, control,

F11 on Mac or control, F11 on Windows.

Instead of jumping back to the first fact with a green background the app now

remembers where it was, and can keep its state through a change of rotation.

Let's click for a couple more fun facts and then rotate it again.

Looks good.

But we still haven't tested what happens when we rotate the app

before hitting the Fun Facts button.

Let's click the back button to close the app, and

then reopen it by clicking it in the app drawer.

Then we can rotate the app using the same shortcut as before.

Function key control F11 on Mac.

Or Control F11 on Windows.

Yikes!

Looks like we found a bug.

To figure out why this is going on, let's step through the code.

Starting at the on create method.

We set our content view.

Then we assign our view variables, and then set up the on click listener.

Then, when we rotate the app, we trigger the on save instant state method

where we add our mFact and mColor variables to our bundle.

But, mFact and mColor haven't been assigned any values

because the OnClick listener hasn't been called yet.

Instead of saving the values we want.

We're saving whatever happens to be the default value for our variables.

Null for strings and zero for integers.

Then after saving our state with mFact as null and

mColor as zero The app re-starts and on create is called.

Then on re-store instant state is called.

We retrieve the values we saved in the bundle, null and zero.

And we update our views with our new mFact and mColor values.

To summarize the problem, we're storing mFact and

mColor in the bundle before we have assigned them meaningful values.

An easy way to fix this is to assign mFact and mColor a value when we declare them.

Since mFact ultimately comes from the m facts array in the fact book class,

we can use the mFacts array to set m fact

to the first fact that we show in the app, the ants fact.

Jumping into the fact book class, tells us that the ants fact is at index zero.

Now we can initialize mFact to the ants fact by typing

= mFactBook.mFacts[0].

Assigning a value to mColor is fairly similar,

mColor ultimately comes from the mColors array in the color wheel class.

Jumping into the color wheel class we see that the green background

we want is at index zero, one, two three, four, five, six, seven, eight.

Let's initialize mColor

to the green color by typing

=mColor wheel.mColors8.

But, since mColors is an array of strings and mColor is an int,

we'll also need to use the color .parse color

method to confer the mColor string end to an end.

Let's do that.

Color.parseColor and

close the parenthesis.

That should handle the case where we're handling our instance state

before it has meaningful values.

Let's run the app to verify that we fixed the bug.

Now when we rotate the app at the beginning, Everything behaves as expected.

Nice work.