We may earn an affiliate commission when you visit our partners.
Stefan Jovanovic

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.

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.

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

Syllabus

Introduction
Application Project Preview
Is this the right course for you?
How is this course structured?
Read more

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! :)

Adding a Custom Material 3 Theme
Project's Source Code
Splash Screen
Design the Splash Screen
Implement the Splash Screen
Mongo DB Setup
Introducing with Mongo DB
Introducing with Realm Sync
Mongo DB Atlas - Create a New Project
Install Mongo DB Compass
Mongo DB Atlas - Enable Google Sign in
Navigation Setup
Setup the Navigation Graph
Authentication Screen
Design Authentication Screen
Implement One-Tap Sign in with Google
Create a User on a Mongo DB Atlas
JWT Authentication Provider with Mongo DB
Dynamically Update the Start Destination
Transparent Status and Navigation Bar
Home Screen
Create a HomeTopBar
Implement the Navigation Drawer

I've made an update video in this course at the end, about the deprecated ObjectId.

Create a DateHeader as a Sticky Header
Create a DiaryHolder Component
Create a Gallery Component

// 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"

    }

  }

}

Define Flexible Sync Permission Rules
Configure the Realm
Generate the Schema with Development Mode
Design a HomeContent
Read all Diaries inside the App
Fix Blank Screen after the Splash Screen
Animate DiaryHolder's Gallery
Animate TopBar on Scroll
Write Screen
Create WriteTopBar

- 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.

Pass Diary Id as an Argument
Fetch Selected Diary Information
Parse Diary Info within a WriteTopBar
Insert a Diary
Modify getSelectedDiary() function
Update a Diary
Adding a custom Date/Time
Fix updatedDateTime lambda
Delete a Diary
Push Screen when Keyboard is opened
Input Fields Focusing
Gallery Uploader
Create a GalleryUploader component
Sign in with Firebase
Generate a Remote Image Path
Upload Gallery images to Firebase Storage
Get Download URL's from Firebase Storage
Create ImagesToUpload DAO & Database
Handle when Image Upload Failed
Implement a Zoomable Image
Fix a Black Write Screen after the Orientation Change
Delete Images from Firebase when a Diary is Deleted
Delete Images from Firebase when Updating a Diary
Create ImagesToDelete DAO and Entity
Filtering the Diaries - Home Screen
Delete all Diaries
Filter Diaries by the Day of the Month
Project Modularization
Introducing with the Modularization
Module Types
Modular Architecture of our Project
Define a Version Catalog
Create a buildSrc Directory
Let's create the first Module - UI
Create a Utility Module
Create a Data Module
Feature Module - Authentication
Feature Module - Home
Feature Module - Write
Apply Visibility Modifiers
Fix the Filter Query
Homework
Homework for practice
Course Updates
#1 'ObjectId' is deprecated. Use BSON ObjectId instead
#2 Empty List fixed, KAPT and Accompanist migration
#3 Kotlin 2.0 and Version Catalog migration

Good to know

Know what's good
, what to watch for
, and possible dealbreakers
Uses Jetpack Compose and Material 3, which are modern tools for building user interfaces on Android, and are recommended by Google
Employs Dagger-Hilt for dependency injection, which simplifies Android development and promotes testable code, and is recommended by Google
Covers Firebase Authentication and Storage, which are commonly used services for user authentication and data storage in Android applications
Integrates MongoDB Realm for data synchronization, which is useful for building offline-first applications and real-time collaboration features
Teaches multi-modular architecture, which is essential for managing large codebases and improving code maintainability in professional Android projects
Includes updates regarding deprecated features like ObjectId and Accompanist Pager, which indicates that the course is actively maintained

Save this course

Save Complete Multi-Modular Architecture for Android Development to your list so you can find it easily later:
Save

Activities

Be better prepared before your course. Deepen your understanding during and after it. Supplement your coursework and achieve mastery of the topics covered in Complete Multi-Modular Architecture for Android Development with these activities:
Review Kotlin Coroutines
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
Study effective Java programming practices to improve the quality of code within each module.
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
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
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
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
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
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

Learners who complete Complete Multi-Modular Architecture for Android Development will develop knowledge and skills that may be useful to these careers:
Mobile Software Engineer
A Mobile Software Engineer focuses on developing applications for mobile platforms, and this course is directly applicable to their work, as it provides practical experience with multi-modular architecture, a critical skill for developers to build scalable and maintainable applications. A mobile software engineer will benefit from the hands-on approach of the course. The course covers important topics like Jetpack Compose and Room, along with cloud services like Firebase and MongoDB, all of which support a modern mobile software engineering role.
Android Developer
An Android Developer builds applications for the Android platform, often working with complex architectures and integrating various services. This course directly helps a developer by providing practical experience with multi-module architecture, a critical skill for large-scale Android projects. The course covers modern Android technologies like Jetpack Compose, ROOM, and Dagger-Hilt, also working with cloud databases such as MongoDB and Firebase, all essential tools for an Android Developer. The hands-on approach, refactoring an existing app into a multi-module structure, mirrors real-world development challenges, making this course ideal for career advancement.
Mobile Application Architect
A Mobile Application Architect designs the structure and organization of mobile apps, focusing on scalability and maintainability and often uses a modular architecture. This course is highly relevant for an architect by teaching how to implement a multi-modular architecture in Android, a structure that promotes maintainability and future growth of an application. The course's emphasis on refactoring an existing app into modules, along with the use of modern technologies like Jetpack Compose and dependency injection, aligns with the needs of a Mobile Application Architect. The course's hands-on approach provides the practical background necessary for designing robust app architectures.
Software Engineer
A Software Engineer develops and maintains software applications, requiring a strong understanding of software architecture and design patterns. The course is useful to a software engineer because it covers how to implement multi-modular architecture, a crucial skill for constructing projects. With practical exercises that involve refactoring code as well as building an application using modern technologies, a software engineer will benefit from the hands on experience. This course helps build a solid foundation in modern software development practices.
Application Developer
An Application Developer builds applications for various platforms, and this course directly helps an application developer focusing on mobile applications. The course provides hands-on training with Android development, including how to structure code using multi-modular architecture, and how to use important tools like Jetpack Compose, Room, and Dagger-Hilt. The course also provides good exposure to cloud based database services, such as MongoDB and Firebase. This experience is crucial to building well structured robust mobile applications.
Mobile Team Lead
A Mobile Team Lead manages a team of mobile developers, ensuring that mobile projects are delivered efficiently and effectively. This course is useful to a mobile team lead because it provides in-depth coverage of modular architecture and modern mobile development practices. The course provides experience with integrating various technologies like Jetpack Compose, Room, Firebase and MongoDB, which are regularly used by a mobile team. This detailed view is especially beneficial when providing guidance to a team.
Full-Stack Developer
A Full Stack Developer works on both the front-end and back-end of applications, and this course may be helpful for those who want to add mobile development to their skills. The course provides a practical experience with building Android applications, including a multi-module architecture, with front-end technologies like Jetpack Compose and back-end technologies like MongoDB and Firebase. This course includes how to handle authentication and data synchronization, which are essential for a full stack developer. This course helps a full stack developer round out their technical capabilities.
UI Developer
A UI Developer is responsible for creating the user interface of applications, and this course introduces a number of tools and technologies they could use. The course covers Jetpack Compose and Material 3, which is directly relevant to building modern interfaces. The course also demonstrates how to create custom UI components and animations which is highly desirable in a UI role. The hands-on approach allows the UI Developer to learn by doing.
Technical Lead
A Technical Lead guides and oversees a team of developers, ensuring projects are completed using a proper architecture. This course may be beneficial for a technical lead by giving them in-depth knowledge of implementing a multi-modular architecture in Android. The course also covers modern technologies like Jetpack Compose, ROOM, and dependency injection, which are essential for overseeing modern Android app development. This course helps build a foundation for the technical lead to guide their team.
Technology Consultant
A Technology Consultant advises organizations on how to use technology to meet their business goals. This course may be beneficial to a technology consultant who wishes to specialize in mobile development. It provides a detailed look at modern Android development by exploring the modular architecture of a complex app and by integrating a variety of technologies. This can help a consultant provide better advice about building mobile applications. This is particularly true if the consultant is helping to decide between different architectural paths.
Backend Developer
A Backend Developer works on the server-side of applications, managing databases and APIs, and this course may be useful to backend developers who are looking to extend their skills to the mobile realm. The course offers in-depth work with MongoDB and Firebase, including authentication, storage, and data synchronization, essential skills for a backend developer who wants to work with mobile applications. The course will also help a backend developer understand how a mobile app connects with the backend by managing data and authentication.
Solutions Architect
A Solutions Architect designs and oversees the implementation of technology solutions to meet business requirements. This course may be beneficial to a solutions architect, as it provides insight into the structure and requirements of developing a complex, modular mobile app. Understanding how to implement a multi-module architecture is important for creating scalable solutions. This course also explores technologies such as Jetpack Compose, ROOM, and MongoDB, which helps a solutions architect design solutions that integrate these technologies.
Cloud Engineer
A Cloud Engineer manages and maintains cloud infrastructure and services, often interacting with mobile applications. The course may be useful for a cloud engineer as it provides direct experience with MongoDB Atlas and Firebase, including data synchronization. This will help them understand how mobile applications interact with the cloud. The course also covers aspects of authentication, which is essential for maintaining secure cloud services. A cloud engineer benefits from this course when they wish to understand the mobile development side of cloud services.
Database Administrator
A Database Administrator manages and maintains databases, ensuring data integrity and availability. This course may be helpful for a database administrator by providing hands-on experience with MongoDB, including how to set up authentication and configure synchronization via Realm. This course also presents various data handling techniques used in mobile applications. Especially the section on how to set up a schema may be relevant. This course will expand a database administrator's understanding of mobile development practices. This course may be especially beneficial when working with organizations that have mobile applications.
Software Development Manager
A Software Development Manager oversees software development projects and teams. This course may be helpful by providing direct experience with a specific architecture for the Android platform. The course covers important technologies like Jetpack Compose, Room, Dagger-Hilt, and MongoDB. This provides a manager with a more detailed perspective of the landscape of modern application development. By seeing the hands on implementation, a manager can better understand the team's work.

Reading list

We've selected two books that we think will supplement your learning. Use these to develop background knowledge, enrich your coursework, and gain a deeper understanding of the topics covered in Complete Multi-Modular Architecture for Android Development.
Provides a deep dive into software architecture principles, including modularity and dependency inversion. It's helpful for understanding the underlying concepts behind multi-modular architecture. While not Android-specific, the principles are directly applicable to structuring Android applications for maintainability and scalability. This book is more valuable as additional reading to deepen understanding.
Provides invaluable insights into Java best practices, which are highly relevant to Kotlin development on Android. Understanding these principles will help you write cleaner, more maintainable code within your modules. While not directly focused on architecture, the coding practices it promotes are essential for building robust and scalable applications. This book useful reference tool for any Android developer.

Share

Help others find this course page by sharing it with your friends and followers:

Similar courses

Similar courses are unavailable at this time. Please try again later.
Our mission

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.

Affiliate disclosure

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.

© 2016 - 2025 OpenCourser