We are so close to being done with this app.

All we have left is to figure out how to manually create our own back stack.

This is one of the headaches about reusing views in an activity like we are, but

I think it's worth it.

In our case it's kind of easy.

We're using ints to control the pages being loaded.

All we need to do is keep track of the ints we use in our own stack and

we will be set.

Lucky for us, Java has a great stack class.

Let's create a new member variable and see how it works.

So let's switch to store activity, got to make sure that we're in the right one.

And up here at the top, let's create a new private stack.

And it's a generic, so we can't use int, that's a primitive type,

remember we've got to use the full blown object.

So we can type Integer like this with a capital I.

And let's name this pageStack.

And we can set it right here.

Let's set this equal to a new Stack type Integer, and there we go.

So adding items to a stack, like adding a piece of paper on a stack,

is called pushing something onto the stack.

So in this example every time we load a page,

we want to push that page number onto this new stack.

So let's go down to load page.

And here the very first thing we can do is add a new line.

And from our new pageStack variable,

we want to push the integer, which in this case is pageNumber.

All right, easy enough.

So this is going to build up a stack of the pages as we go through them.

Now, it's time for the opposite.

When we remove something from a stack, it's called popping from a stack.

And we want to pop from the stack each time the user taps on the back button.

When the back button is pressed, a method called onBackPressed is called, and

we can override that to add our own custom code.

So let's add that down at the bottom here.

It's an activity method.

So at the very bottom before the last curly brace,

let's type onBackPressed and Enter for autocomplete.

So in this case,

the call to super.onBackPressed will execute the normal back function.

If we leave it alone, it will pop or exit the current activity and

go back to main activity, no matter which page of the story we're on.

We only wanna do that when we're on the very first page.

Lets start by popping the current page number from our page stack, pageStack.pop.

We don't need to know what the page number is,

we can just simply remove it from the top of the stack.

All right lets think through this a little bit more.

If we're on the first page of our story,

there will be one page number on the stack.

So this first line will pop it off, meaning that the stack will now be empty.

So we can now run a check for an empty stack like this.

If pageStack.isempty and now in this case,

we want to call super.onBackPressed, and go back to our main activity.

If it's not empty though,

here in the else block, then that means we're on a further page in our story.

We want to load the previous page.

Now this gets a little tricky.

If we get the previous page number and then call load page with it, then we will

push that same page number on to the stack again because that line we added up here

in load page, the very first line, you'll push the page number back on to the stack.

That means that we would end up with the same page number two times in a row

on the stack.

I think it's better to always push the page number in this load page method.

So we can work around this by popping the previous page from the stack

right when we call loadPage back down here.

So what I mean is we'll reload the page right away and for

the page number, we'll pop it right out stack, pageStack.pop

will actually return the popped int, so we can pass it right back into the loadPage.

This looks a little bit funny because we end up calling pop twice in a row, but

it's only because this second call to pop

will then be pushed right back on because we're reloading the page.

So let's review this whole thing one more time.

Let's say we're on page one after starting at page zero.

Our stack will have zero, followed by one.

So let's review this one more time, I review it here with comments.

Let's say we're on page one after starting on page zero.

Our stack will have zero followed by a one.

This first call to pop up here will pop page one from our stack,

leaving only page zero on the page stack.

It's not empty, so when we check here we're going to skip down to the else

block, and now this second block will remove page zero.

But, we are then calling load page, with that zero, and we reload the page and

we will push page zero back on to the stack.

I know this can get a little confusing,

which is why I'm trying to talk through it, in detail.

I think we're ready to try it out though.

I'm going to delete this.

The key is to talk through it and do a lot of testing.

So let's test it out.

All right.

Let's test a few different cases here.

Start the adventure, and

we'll click through until we get all the way to the end.

And now let's use our back button.

Let's see if we go back through the same pages, yeah, it's working, look at that.

All right, we're back at page zero,

and if we hit back again, we go back and the name field is empty.

Let's try it again.

Come in here, we'll go back to the end.

And at this point,

let's click on the up button and we should go all the way up to main activity.

And our name is cleared, very good.

Let's try it one more time.

Let's go through.

Click on a couple of things.

Let's play again, and keep going through.

Sure thing, we can just keep clicking.

And we should be able to click on the back button and go all the way back.

We could even go back, in this case,

through previous stories; which if we really wanted to fix,

we could clear our stack each time we hit play again and load page zero.

But this is great, our app is complete!

You have done it, you have created the interactive story.