Let's hook up our data.

In our MVP pattern, we have the layout here as the view and

our story classes as the model.

Let's load the story into the layout using the presenter StoryActivity.

Let's create a new member variable because we will use our story

throughout this activity class.

So let's add a private Story and just name it story.

Now down here in onCreate,

we can initialize it with our new default constructor.

story = a new Story.

Okay, now we want to load a page from the story

both when the activity is first created and when a button is tapped on.

Sounds like we need a method.

Let's type the method we want to use right here first.

loadPage and the first page we would want to load is 0.

Okay, so now we can use the Android quick fix, Alt plus Enter, and

create this method loadPage.

Okay, so here's our new method and I'm going to change the parameter name for

int i.

Let's call this pageNumber.

Inside this new method, let's create a page named page and

let's hit Alt plus Enter to pull in our new page class.

Again, we do not want either of these PDF pages down here, so

pick the right one and let's set it equal to well, now what?

We need to get a page from our story, so let's keep typing what we want, and

then we can use Android Studio to help us create another new method.

So we want from the story to get a page of the given page number.

All right, so as expected, we don't have this method yet but

we can use another quick fix.

Alt Enter.

Create the method getPage and it adds it over here in our story class.

Looks like I hit an extra key when I hit Enter, okay.

So in here, all we wanna do is return the correct page from our pages array

given the page number parameter.

So we can just do a one line to return pages and pass in the index pageNumber.

Again technically we could access the pages array

directly if we made this a public member variable but

this little bit of encapsulation is a good program in practice.

And just to be safe, let's add a little check here to make sure that we

never request a page that's outside the bounds of the pages array.

So we can say if pageNumber is greater than or equal to pages.length,

then we would get an array out of bounds exception so

instead I'd rather have the app go back to the start then totally crash.

So let's set pageNumber here equal to 0 as a little safety catch.

All right, so back in our story activity,

now we want to wire up the data from this page to our user interface.

We'll start with variables for the views we want to update.

We can add them up top again as member variables so

that we can set them once in onCreate, but then use them in our new loadPage method.

So let's add view variables for the views we're interested in.

private ImageView,

let's call this storyImageView just like we gave it that same ID.

Then we want private TextView storyTextView.

Next we need our two buttons private Button choice1Button and

private Button choice2Button.

Next we can set these down in onCreate.

I like to keep my layout code close together so

I'm going to add some new lines after the call setContentView and

then type storyImageView = cast it to an ImageView.

And then call findViewById(R.id.storyImageView).

We need to do this three more times but for convenience sake, I'm just going to

paste this in and for your convenience, that code is available to paste below.

All right, our pieces are in place.

We have views and we have data so we just need to set the right thing for each view.

Let's start with the image down here in our loadPage method.

We earlier learned how to set the source image for

an image view in the design view of a layout.

Now we can take a look at how to set the source here in code.

So type storyImageView.

And then we want to set the drawable image for this image view,

so let's type setDrawable, and there isn't a setDrawable method,

but look at that, it's called setImageDrawable.

So go ahead and hit Enter for that.

And this method requires a parameter of type Drawable.

Let's create one on the line above.

So we want the Drawable type, and let's just name it image.

And now because we're in an activity which again, is ultimately a context.

We can use another shortcut from the context class to get a drawable resource.

Similar to what we saw previously to get a string resource.

Now this is a little bit different though.

We are going to use a method from another compatibility class called ContextCompat.

So from here we want to use auto complete and type getDrawable

then we pass in the context which is in this case is this.

And the ID of the drawable we want to get.

Let's see, where did we store the ID for the image for a specific page?

That's right, it's right there in the page class.

So from our page variable, call getImageId, which will get us

the appropriate ID to use, then we can add a semicolon and our image is now set.

Well we need to actually pop it in down here.

Lets use the image variable as the new parameter.

We're using this ContextCompat class because Android has evolved how it lets us

display and customize drawable resources over the years.

We used to be able to do this in a very similar way to strings, but

this is a better way to get a drawable now.

All right, this is quite a bit of work so let's run this and

make sure we haven't gone off the rails.

All right, loads up main activity.

I'll type my name.

Tap on the button.

And, okay, we have some success.

The image is showing up in our activity just like we wanted to see.

Let's take a quick break, and then we'll see how to add the rest of our layout.