It's about time we see something happen on the screen.

If we tap on the deck enough, it should eventually become empty and

switch to the blue card.

But for that to happen, we need to call our deck views update method

inside main activities update method.

Let's start in main activity, by creating a new

mutable variable at the top of the class to represent our deck view.

Var deckView.

And for the type, let's specify DeckView?.

Right when MainActivity is initialized, we don't yet have a context.

And we definitely haven't called on create yet.

So there's no way for us to have an instance of DeckView right from the start.

So we'll set it to null for now.

Now that we've got our DeckView property,

let's set it equal to our DeckView function.

And then inside the update function and main activity, let's call deckView.update.

And now we need to decide whether to use a safe call or a non null asserted call.

This update function is triggered by the game presenter whenever a user takes

an action, and users can only take actions on views.

Which means at this point, the views should exist so we should be fine and

asserting that our deck view is not normal.

All right now let's run the app.

And then tap the deck a bunch of times, AKA, exactly 24 times.

And there we go, we've emptied the deck and we see the blue card.

One more tap, and we've recycled the waste pile into the deck.

Now that we've got our deck view out of the way, let's move on to our waste pile.

Let's create a new class named waste pile view.

And then let's make it extend image view.

And then let's add the context parameter just like we had to do last time.

Next, let's add our init function.

And inside, let's set the imageResource to our emptyPileDrawable.

Then, we just need to add an onClick listener.

And inside, all we need to do is call GamePresenter.onWasteTap.

With our new function finished, it's time to move on to the update function.

Let's type fun update, and add our brackets.

And inside this function, if there are cards in the waste pile,

we need to show the top card.

Otherwise we need to show an empty pile.

Let's start by getting a list of which cards are in the waste pile with.

Val cards equals game model .waste pile.

Then let's set image resource Equal to the result of

if (cards.size > 0 and

then let's type two spaces for now and

then add our else and if it is equal to zero it should show the emptyPileDrawable.

Now we just need to find a way to get the right image resource for a card.

So back in our two spaces,

let's call a function that doesn't exist yet

called getResIdForCard(cards.last()).

Then let's use Alt+Enter to create this method.

And let's change the parameter name from last to card.

Inside this function we're going to need to be able to tell

Android the name of the resource we want to show.

Luckily, our resources have nice predictable names.

They're all the word card followed by the suit followed by the value.

So let's start by creating a new val named resource name.

And let's set it equal to, and quotes, the word card.

Followed by a string template to get the card suit.

Card.suit.

And then another string template for

the cards value, which we want to get by using our cards map.

So cardsMap[card.value].

Finally, at the end, let's add a call to

.toLowerCase, to make sure that everything matches.

Then, on the next line, let's return

context.resources.getIdentifier, and

then pass in the resource name for the name

drawable as a string for the type, And

context.packageName for the package, nice.

We're probably going to want this to getResIdForCard method and

more than just this one class.

So instead of having this method be private to our waste pile view,

let's get rid of the private keyword.

And then cut this function and paste it into main

activity, below our empty pile drawable.

For the last step, since it's our views that need the resource ID's let's make

this an extension function on view.

And there we go back and wastePileView all we have left is adding our

Ankle View call just like we did with our DeckView, but before we get to that.

Let's take another look at our DeckView.

At the bottom of our DeckView, we have the DeckView factory,

where we take in a context and return an instance of deck view.

And just like any other lambda expression with one parameter,

we are allowed to omit that parameter and instead just use the it keyword.

Well not exactly.

We can only do that if Cullen is able to figure out what it is,

and Cullen can't do that here.

But what we can do is cut this lambda expression, and

paste it in as the first parameter to anko view.

This first parameter is a function with one context parameter.

So here, it has to be a context and everything works.

Meaning we no longer need our deck view factory, sweet.

Now, to finish out our waste pile view let's copy this ankoView view from

deckView, and then in our wastePileView, let's paste it in below the class.

Then let's change the function name from deckView to wastePileView.

And change the init function to be an extension function on WastePileView.

And lastly,

let's change the factory function to return an instance of WastePileView.

Now that we've finished our WastePileView, let's head back to main activity and

create a new property to store it.

Let's create it right below deck view And name it wastePileView.

Give it a type of WastePileView?, and set it equal to null.

Then inside our layout let's delete the imageView below our deck view And

then set our new wastePileView property equal to our new wastePileView.

Then let's add a call to lparams and pass in the code dimensions.

Finally, inside the update method lets add

a null asserted call to wastePileView.update.

Now, if we run the app we should be able to click on the deck and

see our waste pile start updating.

Looks great.