All that's left is to add a new fragment to handle this new dual-pane layout.

Let's start by creating the layout for this fragment.

And let's name it, fragment_dualpane.

To save time, I've put this layout in the teacher's notes.

So feel free to copy and paste it in.

There's one vertical linear layout, and it contains two horizontal linear layouts.

One, which has two text views to say which side is which, and

the other, which has two frame layouts to serve as placeholders.

When we used the view pager, the view pager took care of

adding our ingredients and directions fragments all by itself.

But now, we need to handle adding these fragments.

So, we've got a leftPlaceholder where we'll put the ingredients fragment, and

the rightPlace holder where we'll put the directions fragment.

Now that we've got our layout, let's create the fragment.

Let's name it DualPaneFragment, and

have it extend the support fragment class.

Then, lets use Ctrl+O to override the on create view method.

And now we need to create our view and initialize our ingredients and

directions fragments.

But since we already do this with our view pager fragment, let's just copy and

paste the top part of view pager fragments on create view.

And paste it back into DualPaneFragment.

And then return view.

Then, let's make these keys the constant from the ViewPagerFragment class.

Since this class and ViewPagerFragment will never co-exist,

we can use the same constant for both.

Next, instead of inflating fragment_viewpager,

let's inflate fragment_dualpane.

And now, just like we do with our activity,

we should check to make sure that a fragment doesn't exist before creating it.

Right below where we set our view, let's add some space, and

first create a variable for our fragment manager,

named fragmentManager.

And let's set it equal to,

getChildFragmentManager because we're in a fragment.

Then, let's add two lines and create a new ingredients fragment variable named,

savedIngredientsFragment.

And let's set it equal to fragmentManager.findFragmentByTag,

and let's pass in, INGREDIENTS_FRAGMENT in all caps.

And then I'll split this into two lines so it's easier to see.

Then lets use Alt-Enter to create the constant and

set it equal to ingredients fragment.

Then, let's use Alt-Enter again to cast the found fragment

as an ingredients fragment.

On the next line, let's check if savedIngredientsFragment is null.

And if it is, we should create a new one.

So let's copy this bit except for the final keyword, and paste it in.

Then, we just need to add this new fragment to our layout

inside the left placeholder.

Right below where we set the arguments inside our if statement.

Let's begin a transaction using the fragmentManager, beginTransaction.

Then let's add a call to add on a new line.

Because I'll run out of space and pass in the ID of the leftPlaceholder.

Our new ingredientsFragment.

And the corresponding tag.

Finally, just tack on a call to commit, And there we go.

We'll only be adding the fragment if it truly doesn't exist.

Now let's do the same for our directions fragment.

Let's copy all of this ingredientsFragment section.

And paste it right below itself.

Then, let's change ingredients to directions.

But check this out.

Let's highlight the section we just pasted and

hit Command or Ctrl-R to bring up the replace menu.

Then, in the top box, type ingredients.

And in the bottom box, type directions.

Then, make sure to check the preserve case check box and then hit replace all.

And now,

all instances of ingredients inside our selection have been changed to directions.

Now let's use Alt-Enter to create the directions fragment tag.

And set it equal to directions_fragment.

And finally, for the directions_fragment.

Let's change leftPlaceholder to rightPlaceholder.

And let's delete this junk at the bottom.

We only copied it over to use as a reference.

Now our DualPaneFragment is ready for use.

Great job.

Over a main activity.

Let's get back to that on grid recipe selected method.

Let's start by copying what we've got in onListRecipesSelected.

And pasting it down here in onGridRecipesSelected.

Then let's change ViewPagerFragment to DualPaneFragment.

And that should do it.

Let's test the app and see what we've got.

Looks great.

But it looks like we forgot to update the title when navigating back from

DualPaneFragment.

Let's fix that by copying the onStop method from ViewPagerFragment, and

pasting it into DualPaneFragment.

Now, let's run the app again.

And if we navigate to a recipe, and then navigate back.

We get the correct title.

You did it.

You fought your way through the fragment managers, defeated the view holders, and

slayed the tablet layout.

Fragments are definitely not the easiest part of Android.

But when used well,

they can make it a lot easier to reuse certain parts of your layout.

And who doesn't love to reuse their code.