
Experience live, unprepared coding as the instructor clones a Play Store app, designs flowcharts and navigation, and launches an Android app in real time.
Build an Android audio recorder app with recording, pause, stop, live data UI, Room database-backed recycler view, media playback, and market research guiding design with Google's architecture guidelines.
Explore the Kotlin code in Android Studio, using a single main activity with playback, record, and list fragments, guided by view models, live data, and Room database concepts.
Setting expectations for this real-time Android app development course, the instructor emphasizes developing problem-solving skills, proactive self-learning, and following along in Android Studio to code and debug.
Learn how to pick an app to clone for revenue by analyzing market data, platform shares, and long-term profitability, while avoiding risky game clones and exploring e-learning opportunities.
Learn how to select a viable Android app to clone by analyzing top free apps, category potential, and monetization, with a focus on tools and an audio recording workflow.
Plan a focused Android recording app around a single, reliable core feature and optimize monetization via recording quality and app store presentation.
Design a simple Android graphical user interface for an audio recorder with a big record button, playback, and a recordings list, while outlining storage, quality settings, and monetization.
Learn to design and implement a mobile UI in Android Studio using Jetpack navigation, including nav graphs, hosts, controllers, and destinations, with fragments and actions guiding screen flow.
Learn to connect two fragments in a nav graph by adding a settings button, creating a settings fragment, and wiring an action with the nav controller to navigate between them.
Create a recording fragment with a recycler view, add it to the navigation graph, and implement actions to navigate between fragments using the nav controller.
Shows adding a playback fragment and its view model, explains MVVM separation, and wires navigation from the record fragment through a nav graph to the playback screen.
Implement Android audio recording with Kotlin using a record fragment and media recorder to capture mic input and save audio. Handle manifest permissions and runtime prompts, and test on devices.
Diagnose recording errors on Android by checking logcat and device selection. Implement proper external storage handling with getExternalFilesDir and informative UI feedback.
Learn how to manage recording state with a view model connected to XML using data binding and LiveData, keeping UI in sync across fragments and lifecycle changes.
Explore wiring view models and live data to Android XML layouts with data binding, and reflect a recording state via isRecording to update button text in real time.
Use an enum to model stopped, recording, and paused states and update record button text via a view model with live data. Clean up observe forever to avoid memory leaks.
Implement play and stop controls in an android recording app using a separate stop button, vector drawables, and live data to toggle visibility and update the record state.
Set the recording file name in an Android app and store it in a database with a unique Unix time based id and a readable timestamp.
Implement changing the stored file name in an Android recording app by wiring the edit text to the view model and persisting the new name to disk and database.
Explore implementing a local Room database in Android by defining a recording entity, DAO, and app database; perform insert and update operations with coroutines and Unix time keys.
Learn to paginate recordings stored in Room using the Paging library with a RecyclerView, wiring up a ViewModel and LiveData to display data in chunks.
Fixes a recycler view by adding a linear layout manager and demonstrates room database paging with paging library version three, using a DAO, view model, and a list adapter.
Set up a click listener to navigate from the record fragment to the playback fragment, passing a recording as an argument via the navigation graph using directions.
Learn how to implement RecyclerView item clicks that navigate from a recording list fragment to a playback fragment, passing the selected recording via a Kotlin click listener.
You have a problem.
Most courses on Udemy are professional and polished which means that instructors are leaving out 70% of the content that you need to know about.
Because of this many students report the following to me and I suspect you've experienced the same:
You take a course and make a dozen little apps
You feel GREAT!
You try to make your own app
You run into one problem after another
You give up
-----------------------------------------------------
The knock on effect of this process is that you never publish anything and that has dire consequences.
If you're freelancing then you cannot show clients a portfolio.
If you're after a job then you cannot show initiative or skill in the interview.
If you're an entrepreneur you cannot build your million dollar idea
But it's not your fault. It's the instructors fault!
-----------------------------------------------------
That's why I created the buildIt Series.
I want to give you back the 70% of content you've been missing out on.
-----------------------------------------------------
buildIt is a series where I go from app idea to design to code to launch.
NOTHING is planned in advance.
EVERYTHING is recorded LIVE.
All coding mistakes are included as well as their fixes.
Watching someone go through the creation process is the only way you can get that missing 70% and discover what being a professional developer is really like.
-----------------------------------------------------
In the end what you get is PRICELESS because you you learn to solve code problems on the fly. Now you can finally finish those projects and publish them:
You will have a portfolio for clients
You will have skills that companies want
You can build your million dollar idea
-----------------------------------------------------
Course Details
In this adventure we go through the following stages, every single one is recorded LIVE using Android Studio and Kotlin:
"I have no idea what to make"
Selecting our app niche
Researching the competition and revenue models
Planning our app
Coding the app (all mistakes included)
Releasing the app
Reviewing revenue and download numbers
There are absolutely ZERO EDITS. Everything is shown in real time, including decision making and research. You'll even catch me copying and modifying code from Stack Overflow (hey, don't judge me, we all do it!).
-----------------------------------------------------
Why no editing?
If you're just getting into coding then you don't really have a true experience of what day to day life is like. This course shows you that reality.
That's why I left out absolutely nothing - even mistakes and buggy code. That way you get a real life overview of being a developer. about 70% of the time is spent correcting my own silly mistakes!
70% of your time will also be spent doing the same so you need to see how it's done!
-----------------------------------------------------
Why did you make this course?
I have over 800,000 students on many platforms and they all struggle with their code, architecture and bugs. This course is the antidote to their problems, primarily aimed at making an app production ready. As far as I know, no other course actually runs through this process.
If you want to experience the real life of a developer then this is the only course that will give you that!
-----------------------------------------------------
Is this for Beginners?
You need to have some experience with code before you attempt this course. As a rough example you should know what classes / objects / variables are. In this course I do explain some things I'm doing but not all of them (else we'd be here for months!).
If you want something extremely beginner friendly then have a look at the other courses I offer.
-----------------------------------------------------
What do we Make?
We will make an Audio Recorder app. It sounds simple - record and play back the audio. However, as a software engineer, "simple" often translates to "pretty complex behind the scenes".
For example:
How do we design the user interface?
Does the design interfere with how we code? (hint: it does)
What are the software engineering practices required to make our code readable?
How few features should we include?
How much code is enough? Should we refactor often?
How to not get caught in endless feature additions and end up never releasing....
And so much more!
If you want more details on the app then check out the free preview videos.
-----------------------------------------------------
Finally, welcome on board and get ready to receive the missing 70% of your education!