All language subtitles for 11. Running the App on an Emulatorf

To wire these two things up and see something on the screen, in main,

we need to execute some code which takes our widget here and draws it to the screen

and for that, there is another function provided by material.dart and that is called runApp. Now

runApp is a normal function but not written by us but written by the Flutter team and exposed in that

material.dart file.

So as you can probably tell, importing that material.dart file unlocks a lot of core features which we

need to build an app. Now runApp does what the name suggests, so it basically runs our Flutter app once

the Android app booted up or the iOS app, whatever it is and that simply means it now tries to take our widget

tree and draw something onto the screen that's based on that tree,

so here it would draw that text here onto the screen. For that

however, we need to tell runApp what our core widget is and that's our MyApp widget of course.

So here we pass MyApp and we execute this like a function by adding parentheses,

that is important,

don't forget these parentheses, otherwise you would use it as a type

but this does not need a type but a concrete object and you instantiate an object based on a class

by adding parentheses.

That's also what we did here when we created our persons, right.

Now runApp does just that, it runs the app, takes our widgets and runs that, to be precise what it does

with our widget is of course it creates that, we're calling the constructor after all, so such a widget

object is getting created and then runApp does take this object which we passed to it in the end here, which

we pass as an argument to runApp, we pass the finished object, the finished widget object here after

all by calling the constructor. runApp takes that and calls the build method for us, that's in the end

what it does and that's how build gets triggered here for the first time and how this

construction of our app then continues and how something gets rendered onto the screen and therefore

if we now save that file and we go to debug and again start this without debugging, we should now be

able to bring this back onto the emulator and see a very basic and ugly application there, which somewhere

outputs

hello.

And as you can also tell therefore is that we basically only care about the user interface and what we

see there and that's a cool thing. We don't have to care about rendering individual pixels or managing

the lifecycle of the app, starting it up and listening to events on the home screen of our Android device,

we do none of that,

what we do here is we control what ends up on the screen.

So now this is getting built into an apk here for my Android emulator,

once it's done, it launches up and we see this. Now

this is the expected result,

we haven't defined any styling,

we haven't defined anything that will lead to something more beautiful being rendered but we see hello

here.

And that therefore proves that this basic code works, that we created our own widget class which is a

normal class with some extra features provided by stateless widget and that this was accepted by the

main function to run our app with the help of runApp.