All language subtitles for 4. Understanding the Flutter Architecturef

So now that we know what Flutter is or that we at least have a rough idea about that,

let's have a look at the architecture of a Flutter application and there, the most important thing

which you'll see over and over throughout the course is that Flutter has that idea of building user interfaces

as code,

that's called UI as Code. You build a widget tree in your Flutter apps and I'll come back to that

in a second,

in the end the idea is that you will have no visual drag and drop editor for adding buttons or text

inputs to your screens, to what the user sees,

instead you'll work only in code, we'll write everything in code

and whilst this might sound intimidating at first,

you will see the Flutter has a really nice approach for that, which makes creating interfaces with this

UI as Code approach a breeze.

Now besides this core idea of how you build your apps in Flutter, this UI as Code approach, it's also

important to understand that Flutter apps do actually embrace platform differences, whilst being based

on one codebase.

So we work in one project but we will still have the ability to create different user interfaces at

some points or in some parts of our app if we need it for the different platforms

because Android and iOS are not exactly the same.

They're not just for different phones,

they do have some small differences and sometimes, that doesn't matter to you

but if it does, Flutter gives you the tools to find out on which platform you're running, so that if

you're on Android, you can execute code A

and if you're on iOS, you can execute code B, so Flutter gives you the full flexibility there.

Now let's first of all have a look at that widget thing again.

In Flutter,

everything's a widget, that's important to understand.

If you had an app that looks like this, then this is a bunch of widgets. For example here,

the app bar at the top with the tabs in there,

that's one huge widget with a lot of smaller widgets in there and all these elements on the screen are

just widgets in the end,

you build your entire screen, your entire app from such widgets.

Actually the whole page is a widget

and even the whole app is wrapped in one main widget and a widget as you will see throughout this course

is really just a code snippet, an instruction you placed in your code, something like Please render a button

here,

that's a widget,

it'll be as simple as that and your entire app is therefore built as a widget tree.

You have this root widget which is your app itself, then you might have different screens there, on

the different screens, you have different sections and in there you might have text inputs, text outputs,

buttons, tabs, drop downs and a widget might hold other widgets, for example your tabs widget might hold

individual tab widgets

but thinking about this in an abstract way can be really difficult and therefore for now, just keep that

term "widget tree" in mind,

we'll have a look at how this works and how this looks and we'll actually write all the code for that

together throughout the

course. Now this UI as Code concept is also important,

if you had an application that looks like this here, then as I mentioned earlier, you don't build it by

dragging and dropping elements into a visual editor,

you have no visual editor indeed,

instead you only work in code.

The code for this could look like that here and here you already get a brief preview at how these widgets

work and how you structure your entire app with the help of these widgets, how you configure your app

with these widgets

and as you can see, even without understanding that code, that probably doesn't look too difficult. In

the end,

here we just have a bunch of instructions on what should get rendered on the screen and how the different

things are related

and of course you'll learn all about that throughout the course.

So this is extremely straightforward way of building your app

and I will introduce you to this approach carefully step-by-step.

We'll build our apps from scratch and I will introduce you to the core widgets and how they work together

step-by-step in this course. Now this one codebase thing or concept is also important to understand.

In the end, you will have a bunch of Dart files in your project and these will make up your application

and you build a Android and an iOS app based on that one project

but as I mentioned, if you need to, you can still find out on which platform you are running and then

render different content based on that platform.

So these are the core Flutter ideas,

again if they're not 100% clear at this point, that's normal,

we just started,

we'll of course use all these features and go through all these features step-by-step as we progress through

the course.