So what's in this course now? What will you learn in this course?
We're almost done getting started and therefore with this basic module, we set everything
up and you get a rough idea of what React Native is and how it works.
After this, we'll of course have a very important module where we dive into the React Native basics. In
this module, you learned all the core fundamentals you need to know about React Native - how these apps
work, how you work with React Native components, how you build your own components, how you make that all
work as a native app, what you can test on your emulators or real devices,
all of that is in this super important module.
Now after all these core basics which are really important, we'll also have a look at debugging.
How can you track down errors?
Which tools are there to help you with debugging?
these are all questions we'll tackle in the debugging module.
Now thereafter, we will dive back into the basics but into the advanced basics if you want to call
it like this. We'll have a look at how you build real apps, how you style apps, which different options
you have there, how you work with all these components that are baked into React Native and with your
own components that you can build based on those, how you layout your apps,
so here we'll really bring together many concepts and compose that all in a more realistic app which
does more useful things and where we'll need to tackle certain problems you have to tackle in real apps.
So that's another core module for you to learn how React Native works and how React Native apps are
built.
Now once we completed this module, we'll have a solid understanding of all these fundamentals but there
will be one problem. Up to this point,
the apps we built thus far are not really flexible,
they're not really adapting to different screen sizes and there might be differences between iOS or
Android
regarding how apps should look like or how certain things should behave which we don't really cater
for. Therefore we'll then have a module where we dive into how to build responsive and adaptive apps,
so how you make sure that your apps look great and work the way they should work on different devices,
different device sizes and also on different platforms,
so on Android and iOS and how you can use one project and one codebase to still fine tune your app to
different platforms in certain areas.
Now after all of that, you'll have very solid fundamentals but we'll also only have worked on apps that
have mostly one screen.
Now in most apps, you have tabs, you have a side drawer, you can navigate forth and back between different
pages and you have nice transitions and animations for these navigation actions and therefore, we'll have
a whole module dedicated to navigation and how you can build navigation into your app, how you can provide
beautiful transitions, how you can add tabs, different kinds of tabs to your application and all these
core techniques and things that you need in most applications you're going to build.
Now by then, we'll also have a feeling for a problem, that managing state, managing data in our application
can be tricky as our application grows and therefore we'll then have a whole module where we dive in
to how to manage state with the help of Redux and how you can pass data around in your application.
After all of that, it's really time to practice and therefore, we'll have a whole module where we build a
brand new application from scratch, where we incorporate all the things we learned thus far.
That's a module where you can practice this on your own or you just follow along with me or you practice
first and then compare your solution to mine,
so it's a big practice module where all these core things we learned about come together and can be seen
in practice.
Now after that, we'll take that same app and enhance it, for example by handling user input in a better
way, by validating it, by showing error messages, by making sure that our app has certain data criteria
that needs to be fulfilled before we can continue and so on. So that's
another core module because of course in many applications, you'll need to gather user input.
Now thereafter, we'll also leave our application in a certain sense because we'll learn how to send data
to a server and store it on that server in a database.
Of course, that's another crucial task because not all data lives on your device,
instead there is some data that needs to be shared with other users for example or that should be backed
up or that should be available even if users reinstall your app and for all of that, that data needs
to be stored away from your app,
it needs to be stored on a server, it needs to be stored in a database and that's exactly what we'll
have a look at in this HTTP Requests Module. Now
speaking of servers and so on, many applications also need user authentication. You need to be able to sign users
up and log them in, log them out, manage their session
and that's exactly what we'll have a detailed look at in the user authentication section, another core
section with another core feature that you need in many applications and we'll have a detailed look
at all of that in this module.
After this module, you will have a lot of core building blocks you need for apps you typically build
but one thing will be missing and that's how you tap into native device features, how you can use the
device camera, how you can get the user location or how you can use Google Maps and that's what we'll
have a look at in this native device features module. You will learn how you can get the user location,
how you can use it, how you can store it on an on device SQLite database, all that fun stuff is in
this module and therefore, this is another crucial module of course. Now thereafter, I'll dive into different
ways of building your React Native app because for the majority of this course, we actually use expo, the
tool we got started with in this first course module because it makes building React Native apps such
a breeze, it's such fun, it's easier and therefore definitely my recommended approach
but you might not always want to use it
and in this module, I explained when you might not want to use it and how you then build apps without
it, though I can already have a little spoiler at this point, for most applications, the vast majority,
expo is an amazing tool and also important, really important, all what you learned in this course
can be applied to expo and non-expo apps and I make that clear in this different workflows module as
well and I show how non-expo works and how you write code for them and surprise,
it's exactly the same as you learned in the rest of the course basically.
Now thereafter, we of course aren't really there to just build app and then throw it away,
instead you typically want to publish it.
So I'll have a whole module focusing on how you publish apps and we'll not just have a look at how
you build it and how you then get it into the App Store,
we also will have a look at over the air updates for example, how you can automatically update the installed
apps without forcing your users to redownload an updated version which is really amazing, so that's
also covered in this module.
A lot of content, all these modules of course are extremely detailed,
you'll get tons of knowledge about React Native and by the end of the course, you'll be able to build
amazing React Native applications.