Okay, so now that we've got a fuzzy understanding of how this all works,

let's take a step back and see if we can make things a little bit clearer.

Here we are in main activity where our code that creates the layout.

It starts with a call to the relative layout,

which is an extension function on activity.

And, actually, that's all this code is, just one big function call

to relative layout, with one parameter that happens to be another function.

So inside a relative layout function, this passed in function will be the init

parameter, then all we have to do is, return the result of calling ankoView

with the relative layout constant and our init function.

And, remember, the relativeLayout constant is just a simple function

that takes on a context and returns an instance of underscore relatively layout.

From here, we call the ankoView method and

pass along our init function along with our underscore relativeLayout constant.

And note that we're calling the version which is an extension function

on the activity class.

So inside this function this keyword will be an activity.

Moving on to the end side of the function,

we start by creating a variable to hold the context.

Then we pass this context to our factory to give us an instance of

underscore relative layout.

Next, we call our init function on our new layout,

which brings us to the inside of our init function.

Inside the init function,

we start with the call to text view, which is an extension function on View Manager.

But, don't worry, I looked into it and View Manager is an interface that gets

implemented by relative layout, so we're good.

Next, just like with our relative well function, we're passing in another

function to our text view function, and it gets passed in as the init parameter.

Now we're calling anko view again, but this time with the text view constant and

a different init parameter.

So let's pass those in, and also,

note that this time we're calling the View Manager version of ankoView.

So this key word will be our view manager, AKA, our relative layout.

Back inside the ankoView function, we grab a context and

use it alongside our factory function to create a text view.

Then, we call in it on our text view and it sets our text view ID to 11,

its text to 0, and its text size to 24.

Once that's done,

we're back in our ankoView function where we add our TextView to a relative layout.

Then, we return our TextView, and

return it again, and then it get sets to our counter TextView variable.

After that,

we march on to the button function where we again pass in another function.

Just like last time, we end up calling ankoView within an init function and

a view factory, but this time it's a different init function,

and the view factory returns buttons.

So inside ankoView, we grab our context, create a button using that context, and

then initialize that button with our init function,

which adds on clicklistener to our button.

Back in ankoView, we then add our button to a relative layout,

and then return our button, and return it again.

But this time, instead of setting some variable equal to our button we

immediately call the lparams function on our button, and

again, we pass in another function.

Inside the lparams function, we start by creating a relative layout,

layout params object.

Then, we call our init function where we modify the layout params

to say that this view, our button, should be below our text view.

Then we set our buttons layout param to our newly created and

initialized layout parameters.

And, finally, we return our button,

which brings us to the end of our relative layouts init function.

And once that's done, we're back at the activities ankoView function where we

add our relative layout for our activity, and then return our relative layout.

Then we return it one more time, which brings us back to the end of our layout.

That was a lot, but on the plus side, now we've got an excellent understanding

of how Anko works, and trust me, this will make the rest of the course a lot easier.

Speaking of the rest of the course,

it's about time that we get back to our solitaire game.

I mean, it's pretty cool that we can see the game in our debug log, but

what good is a game if you can't play it?

So, from here on out we'll be focused on using what we just learned

to implement the UI for our game.