Let's take one last opportunity to talk about an important app design

consideration.

Android uses a concept of back and up navigation in apps.

This section here in design docs has a lot of good information about how these work,

and how we should implement them.

Back seems pretty obvious.

Just like using the back button in a web browser,

the Android back button should step a user backwards through their app activity, or

even through other apps if they happen to enter our app from within another one.

In interactive story, that means that the back button should page the user back

through the story, which it currently doesn't do.

This is one reason I thought about using an individual activity for

each page in the story.

Had we done so,

we'd automatically be able to navigate backwards through the activities.

This is, because of the back stack I alluded to briefly earlier.

Think of our navigation as a stack of papers.

Each activity we navigate to gets added as a new paper on top of the stack.

Right now our app fires up with the MainActivity as the only

paper on the stack.

Then when we start the story we put the story activity on top of it.

Each activity that we navigate to gets added to the stack in the same way, then

we hit the back button, the top most item from the stack is removed, or popped off.

And we can keep going, all the way back to the first item.

And if we hit the back button from there, that activity is also removed,

which means we exit our app.

Android also has an up button in the app bar, but

we need to set something to make it work.

Up navigation refers to navigating up through different levels of an app.

Sometimes, the up and back button will do the same thing.

But our app is a good example where the main activity is at the first level.

And all the story pages are at a deeper level of the app.

So, tapping on the up button in the app bar should take the user

up to the main activity.

But tapping on back should take them back through pages in the story.

Let's tackle the up button first, simply, because it's easier.

To establish this hierarchical relationship between activities,

we need to set main activity as the parent of story activity.

Not in the subclass parent class sense like Java, but in our AndroidManifest.

So, here we have the activities defined, and

in story activity, let's add a new line before the ending angle bracket.

And a new attribute Android:parentActivityName.

And then we can slot MainActivity from auto complete.

Okay, let's run this to see how it looks.

Okay, so, now, start the app, go in.

And look at that we have a new button here.

So, we can go anywhere into our app.

And if we hit this up button.

There we go.

Up to the main activity again.

And here's an example of where up and back work the same way.

So, if we go in, and then hit up right away we go back and

if we do the same thing.

Go in and hit back.

We're taken right back.

Now, this is interesting.

Notice that the name persisted when we hit back, but not when we hit the up button.

I'd like the name field to be reset upon coming back to this main activity

every single time.

So, let's set that and make sure that it's always blank like this.

So, let's go back to mainactivity.java, and

the reason the name is sticking from the back button is,

because we're reusing the same instance of main activity from before.

It's not guaranteed to still be a memory, but it's pretty likely and that means that

it's displayed in the same state we left it in, with the name already entered.

All we need to do is reset the edit text to a blank value.

Now, the issue is, we can't do that here in our on create method,

because when an activity is resumed by going back to it like we just did,

it uses a different life cycle method called on resume.

We have a whole course that talks about activity life cycle, but

we can quickly fix it here.

So, below our on create method, let's add a new line and type, onResume.

And use our auto complete to drop in the method.

So, inside here, after the call to super.onResume(),

type nameField.setText, and we'll just pass in a blank value like this.

Here's a fun fact, onResume will always be called after onCreate.

This line of code will always run when the activity is first created, and

when it is resumed by the back button, just what we need.

Let's run it again to make sure.

So, now, we'll go in enter our name, start the activity.

Either we hit the back button the name is cleared out,

and just to make sure we'll start it again and hit the up button.

Okay, in the next video, we'll see how to maintain our own custom back stack for

our pages before wrapping up this course.

Here, almost there!

Power on through!

I'm proud of you!