In this course I'm going to teach you how to build an Android Application by implementing the Multi-Modular Architecture. You will learn everything about properly configuring the project in order to make a maintainable structure that can grow easily.
Read more
In this course I'm going to teach you how to build an Android Application by implementing the Multi-Modular Architecture. You will learn everything about properly configuring the project in order to make a maintainable structure that can grow easily.
In this course I'm going to teach you how to build an Android Application by implementing the Multi-Modular Architecture. You will learn everything about properly configuring the project in order to make a maintainable structure that can grow easily.
Modularization is an unavoidable Architecture when working on a big, industry level code bases that pretend to expand furthermore. Almost every employer our there, will appreciate your experience with working on a multi-modular projects. But that can be tough when you are a beginner, since it's hard to find a quality source of information on this topic. However, with that knowledge, it means that you will definitely stand out from the crowd when applying for a job. You will feel confident.
This course is a beginner friendly. Which means that you don't need to have any experience with this kind of an architecture, to be able to follow along. And the proof of that is the actual structure of this same course. First, we are going to build an android application without the multi-module architecture, so that you can get introduced with the project itself. And only after we fully complete the app, then we are going to refactor the project, and split it up into multiple different modules.
That way you will learn not just how to create and maintain a multi-module project, but also how to refactor an existing project to follow that same architecture and structure.
We are going to build a beautiful Diary application by using the newest API's and technologies for Android Development. Like the ROOM library for a local database, Jetpack Compose for building the UI of our application, New Splash API, Material 3, Kotlin Coroutines, Dagger-Hilt dependency injection library, One-Tap Sign in with Google, Firebase Authentication, Firebase Storage, Mongo Authentication, Mongo Realm Database, but also a Mongo Realm/Device Sync service as well.
With Device Sync we will be able to easily synchronize the data between a client-side database(Android) and a powerful, fully managed back-end in Atlas. With out-of-the-box networking code and conflict resolution. Device Sync is especially helpful for apps that must continue to function when are offline, or apps that offer real-time collaboration.
When offline, changes in the database will be saved locally, until you receive back an internet connection, when the changes will be automatically pushed on the back-end without any action from your side. Which is amazing.
With a Mongo Device Sync, you will be able to build Industry-ready apps quite easily,with minimal effort.
Bottom line, this course is going to teach you a lot of stuff.
Wait no more and enroll now.
What's inside
Learning objectives
- Multi-modular architecture for android development
- Mongo db
- Mongo authentication
- Mongo db realm
- Mongo db realm/device sync
- Mongo atlas
- Realm kotlin sdk
- Synchronize the data between a client and the server
- Jetpack compose
- Material 3
- Dagger-hilt
- Room database
- Firebase authentication
- Firebase storage
- Google authentication
- One-tap sign in with google
- Splash api
- Jwt authentication
- Animation
- Custom ui components
- Diary application
- Flexible sync
- Permissions
- Version catalog
- And more...
- Show more
- Show less
- Multi-modular architecture for android development
- Mongo db
- Mongo authentication
- Mongo db realm
- Mongo db realm/device sync
- Mongo atlas
- Realm kotlin sdk
- Synchronize the data between a client and the server
- Jetpack compose
- Material 3
- Dagger-hilt
- Room database
- Firebase authentication
- Firebase storage
- Google authentication
- One-tap sign in with google
- Splash api
- Jwt authentication
- Animation
- Custom ui components
- Diary application
- Flexible sync
- Permissions
- Version catalog
- And more...
- Show more
- Show less
Syllabus
Introduction
Application Project Preview
Is this the right course for you?
How is this course structured?
Read more
Syllabus
At the time of recording this course, a version catalog was not present in a default android with jetpack compose project template. However in the last section, the lesson #80, I've showcased how to migrate to a new Kotlin 2.0, but also how to migrate to a new version catalog as well. You can find an updated repository nonetheless. If you have any questions, feel free to let me know! :)
I've made an update video in this course at the end, about the deprecated ObjectId.
// Sync Permissions
{
"rules": {},
"defaultRoles": [
{
"name": "owner-read-write",
"applyWhen": {},
"read": {
"ownerId": "%%user.id"
},
"write": {
"ownerId": "%%user.id"
}
}
]
}
// JSON Schema
{
"title": "Diary",
"bsonType": "object",
"required": [
"_id",
"ownerId",
"mood",
"title",
"description",
"date"
],
"properties": {
"_id": {
"bsonType": "objectId"
},
"ownerId": {
"bsonType": "string"
},
"mood": {
"bsonType": "string"
},
"title": {
"bsonType": "string"
},
"description": {
"bsonType": "string"
},
"images": {
"bsonType": "array",
"items": {
"bsonType": "string"
}
},
"date": {
"bsonType": "date"
}
}
}
- Some of "TextFieldDefaults.textFieldColors()" colors were deprecated. Check out the last section of this course for the newest updates, or you can also visit the repository as well.
- Accompanist Pager is now Deprecated. Check the last section of this course for the updates.
Traffic lights
Save this course
Save
Reviews summary
Analysis of complete multi-modular architecture for android development
Instructor provides updates for changes.
Building a real diary app was engaging.
Covers many modern Android technologies.
Suitable for beginners to modularization concept.
Effective method to teach modularization.
Activities
Review Kotlin Coroutines
Show steps
Refresh your understanding of Kotlin Coroutines to better grasp asynchronous operations within the Diary application.
Browse courses on
Kotlin Coroutines
Show steps
-
Read the official Kotlin Coroutines documentation.
-
Work through a basic coroutines tutorial.
-
Review examples of using coroutines for network requests.
Review 'Effective Java' by Joshua Bloch
Show steps
Study effective Java programming practices to improve the quality of code within each module.
View
Effective Java (3rd Edition)
on Amazon
Show steps
-
Read the book's sections on design and coding practices.
-
Apply the principles to your Android code.
-
Refactor existing code to adhere to these practices.
Review 'Clean Architecture' by Robert C. Martin
Show steps
Study the principles of clean architecture to better understand the reasoning behind multi-modular architecture.
View
Clean Architecture
on Amazon
Show steps
-
Read the book's sections on component principles.
-
Relate the principles to Android module design.
-
Consider how these principles apply to the Diary app.
Four other activities
Expand to see all activities and additional details
Show all seven activities
Create a Simple Modularized App
Show steps
Practice building a small Android application with a multi-modular architecture to solidify your understanding.
Show steps
-
Plan a simple app with 2-3 features.
-
Create separate modules for each feature and a core module.
-
Implement basic functionality in each module.
-
Test the communication between modules.
Document the Modularization Process
Show steps
Create a blog post or documentation outlining the steps and considerations for modularizing an Android application.
Show steps
-
Outline the key steps in modularization.
-
Explain the benefits of multi-modular architecture.
-
Provide code examples and diagrams.
-
Publish the documentation on a platform like Medium or GitHub.
Refactor a Sample App
Show steps
Download a simple, non-modular Android app from GitHub and refactor it to use a multi-modular architecture.
Show steps
-
Find a suitable sample app on GitHub.
-
Analyze the app's structure and identify modules.
-
Refactor the code into separate modules.
-
Test the refactored app thoroughly.
Contribute to an Open Source Android Project
Show steps
Contribute to an open-source Android project that uses multi-modular architecture to gain real-world experience.
Show steps
-
Find an open-source project on GitHub.
-
Identify a bug or feature to work on.
-
Submit a pull request with your changes.
-
Respond to feedback from the project maintainers.
Review Kotlin Coroutines
Show steps
Refresh your understanding of Kotlin Coroutines to better grasp asynchronous operations within the Diary application.
Browse courses on
Kotlin Coroutines
Show steps
- Read the official Kotlin Coroutines documentation.
- Work through a basic coroutines tutorial.
- Review examples of using coroutines for network requests.
Review 'Effective Java' by Joshua Bloch
Show steps
Study effective Java programming practices to improve the quality of code within each module.
View
Effective Java (3rd Edition)
on Amazon
Show steps
- Read the book's sections on design and coding practices.
- Apply the principles to your Android code.
- Refactor existing code to adhere to these practices.
Review 'Clean Architecture' by Robert C. Martin
Show steps
Study the principles of clean architecture to better understand the reasoning behind multi-modular architecture.
View
Clean Architecture
on Amazon
Show steps
- Read the book's sections on component principles.
- Relate the principles to Android module design.
- Consider how these principles apply to the Diary app.
Create a Simple Modularized App
Show steps
Practice building a small Android application with a multi-modular architecture to solidify your understanding.
Show steps
- Plan a simple app with 2-3 features.
- Create separate modules for each feature and a core module.
- Implement basic functionality in each module.
- Test the communication between modules.
Document the Modularization Process
Show steps
Create a blog post or documentation outlining the steps and considerations for modularizing an Android application.
Show steps
- Outline the key steps in modularization.
- Explain the benefits of multi-modular architecture.
- Provide code examples and diagrams.
- Publish the documentation on a platform like Medium or GitHub.
Refactor a Sample App
Show steps
Download a simple, non-modular Android app from GitHub and refactor it to use a multi-modular architecture.
Show steps
- Find a suitable sample app on GitHub.
- Analyze the app's structure and identify modules.
- Refactor the code into separate modules.
- Test the refactored app thoroughly.
Contribute to an Open Source Android Project
Show steps
Contribute to an open-source Android project that uses multi-modular architecture to gain real-world experience.
Show steps
- Find an open-source project on GitHub.
- Identify a bug or feature to work on.
- Submit a pull request with your changes.
- Respond to feedback from the project maintainers.
Career center
Mobile Software Engineer
Android Developer
Mobile Application Architect
Software Engineer
Application Developer
Mobile Team Lead
Full-Stack Developer
UI Developer
Technical Lead
Technology Consultant
Backend Developer
Solutions Architect
Cloud Engineer
Database Administrator
Software Development Manager
Reading list
Save
Share
Similar courses
OpenCourser helps millions of learners each year. People visit us to learn workspace skills, ace their exams, and nurture their curiosity.
Our extensive catalog contains over 50,000 courses and twice as many books. Browse by search, by topic, or even by career interests. We'll match you to the right resources quickly.
Find this site helpful? Tell a friend about us.
We're supported by our community of learners. When you purchase or subscribe to courses and programs or purchase books, we may earn a commission from our partners.
Your purchases help us maintain our catalog and keep our servers humming without ads.
Thank you for supporting OpenCourser.
