We've got a pizza object and a topping object.

And when the app is created we use the toppings list

to generate our topping bitmaps.

With that out of the way let's move on to the activities.

We've got main activity, which was the list of pizzas.

And creator activity, which let's us customize the pizzas.

Let's start with main activity.

At the top of the file, we've got a pizza ID constant.

Other than that, we just find the recyclerview.

Give it a layout manager, and set it up with an adapter.

If you've not seen something like this before, don't worry.

It's just an anonymous function stored in a variable.

So launch creator activity is a function that takes in an integer

which might be null and when this function runs, it will create an intent,

add the pizza ID to the intent and then start creator activity.

So, let's jump into Main Adapter and start from the top.

You can use Cmd or CTRL+B to jump to a class from its usage.

First, we've got our LaunchCreatorActivity function as the only parameter.

And as we just saw it takes an integer that might be null and returns nothing.

From here, we have a list of pizzas which will contain the pizzas

to display on the screen.

Each row in this RecyclerView will use the pizza row layout.

If we take a look at that layout, under Resources and the Layout directory.

We can see that it contains a text view for the name of the pizza,

a create new pizza button and a divider line at the bottom.

So instead of using multiple views for the pizza rows and

the create new pizza button, we just used this one view and we'll hide the elements

we don't need depending on whether we wanna show the pizza or the button.

Getting back to the adapter, let's move onto the view holder.

Back in the code we can see that the item count is one more than the size of

the list, this is to account for the new pizza button at the bottom.

Moving on to the view holder, we show or

hide the views depending on which type of row it is.

So, if it's not the last item in the list, we'll hide the button and if it is

the last item in the list, we'll make the button visible and hide everything else.

We also set up the on click listeners to call through to our

launch creator activity function.

If it's a pizza row that was clicked, we'll pass in the ID of the pizza.

And if the new pizza button was clicked, we'll just pass in null.

So regardless of which row we click, we'll end up launching CreatorActivity.

Let's hop over to CreatorActivity and see where we go from here.

Let me give us just a little more room here as well.

Let me just hide it instead.

At the top of CreatorActivity we create a pizza ID variable and

lateinit it another variable named pizzaView.

In Cotland, when you create a variable you have to give it a value.

But with lateinit, we can get around that.

We just need to make sure it gets initialized before we use it.

Speaking of PizzaView, let's take a quick detour of the PizzaView class.

Remember, Cmd or Ctrl+B on the class name will jump us into the class.

PizzaView is a custom view, meaning it extends from View that draws a pizza.

It starts by drawing a big circle for the crust.

Then it draws a smaller circle for the body of the pizza.

And finally draws each of the toppings on top.

To tell it which toppings to draw, we pass in a map of toppings to Booleans.

If a topping is paired with the value of true, we draw it.

Otherwise we don't and that's about all we need to know about the PizzaView class.

Though, feel free to pause me and

look through the rest of this code if you'd like.

Getting back to CreatorActivity and the onCreate method,

we retrieve the Pizza ID from the intent and

initialize our PizzaView to an empty pizza, by passing in an empty map.

Later on when we have some data, we'll update this map to not be empty.

From here we add our PizzaView to the frameLayout at the top of the screen and

set up our recyclerView that lives at the bottom.

To finish out CreatorActivity,

we've got a couple methods to set up the menu at the top of the screen.

On create options menu, creates the menu and

on options item selected is where we add functionality to the menu items.

The last class we need to look at is CreatorAdaptor.

This class manages the recyclerView at the bottom of CreatorActivity.

And as a parameter, it takes in a pizza view.

With this pizza view at the bottom, when a switch is checked,

we update the toppings mapping with the state of the switch and

tell the pizza view to update by calling the invalidate method.

Awesome we've now got a good understanding of the app, and

are ready to implement that resistance, I know that was a lot to cover.

But don't worry, from here on out we'll be taking things one step at at time.

And if you want to spend some more time playing around and

getting comfortable with the app, please do.

I'll be here waiting for you when you get back.