Mastering Multi-Modular & Clean Architecture In Android

Advanced Android Course:MVVM, Multi-Flavored Builds, Data Store, Advacned Gradle, Custome Plugins, Networking

What you'll learn

Creating and organizing buildSrc modules.

Managing build configurations: BuildConfig, PluginsConfig, ReleaseConfig.

Handling build types, flavor types, and app dimensions.

Securing signing configurations and managing credentials.

Implementing shared dependencies across modules

Creating and managing shared library Gradle plugins.

Implementing code quality tools: KTLint, Spotless, Detekt.

Adding and organizing feature modules.

Structuring dependencies within feature modules and across the app.

Dependency Injection and Networking

Setting up Dagger-Hilt for dependency injection.

Configuring and managing networking components: Retrofit, OkHttp.

Implementing custom request headers and interceptors.

Securing network requests with SSL, dispatcher management, and certificate pinning.

Designing a flexible OkHttpClient provider interface.

Error Handling and Response Management

Building error handling models and flexible result wrappers.

Mapping and processing network responses and errors.

Implementing network data sources.

Data Layer and Serialization

Working with DataStore (Kotlin Serialization, Proto DataStore).

Creating and managing serializers for app settings and session management.

Integrating DataStore with Dagger-Hilt.

Authentication and Authorization

Implementing session management and token handling.

Developing authentication interceptors with token refresh and Mutex synchronization.

Handling unauthorized tokens and secure retry mechanisms.

Managing UI state, validation, and error handling.

Network debugging with tools like Chucker.

Generating build version reports.

Integrating code documentation with Dokka.

Creating and managing mock APIs.

Requirements

Android Development Experience

Experience with Dependency Injection

Working Knowledge of Gradle

Description

"Mastering Multi-Modular & Clean Architecture in Android" is an in-depth course designed to elevate your Android development skills, focusing on building scalable, maintainable, and testable applications. This course covers the entire spectrum of multi-modular architecture, from foundational concepts to advanced implementation techniques, ensuring you have the expertise to handle complex app development projects.You’ll begin by learning how to set up and organize buildSrc modules, manage build configurations, and handle build types, flavor dimensions, and signing configurations securely. The course emphasizes the importance of modularization, guiding you through adding and organizing feature modules, structuring dependencies, and creating shared Gradle plugins to streamline your development process.The course delves deep into dependency injection with Dagger-Hilt, teaching you how to configure and manage networking components using Retrofit and OkHttp. You’ll explore advanced topics like implementing custom request headers, SSL management, certificate pinning, and designing flexible OkHttpClient provider interfaces.Error handling and response management are thoroughly covered, with lessons on building robust error models, mapping network responses, and implementing flexible result wrappers. You’ll also gain expertise in creating and managing a data layer using Kotlin Serialization and Proto DataStore, integrating these with Dagger-Hilt for efficient data management.UI development with Jetpack Compose is a key focus, where you’ll learn to create dynamic login screens, manage UI state, handle validation, and structure login flows effectively. The course also covers network debugging tools like Chucker, build automation, and maintaining high code quality through tools like KTLint, Spotless, and Detekt.Additionally, the course addresses crucial aspects of authentication and authorization, including session management, token handling, and implementing secure authentication interceptors. You’ll also explore advanced error handling techniques, such as retry mechanisms with Mutex synchronization.By the end of this course, you’ll have a comprehensive understanding of multi-modular architecture, clean code practices, and modern Android development techniques, making you proficient in building complex, enterprise-level Android applications. Whether you’re looking to refine your existing skills or advance your career, this course offers everything you need to master Android development.

Overview

Section 1: Start with Advanced Build Source architecture

Lecture 1 Lect-6 - Start Adding BuildSrc Module

Lecture 2 Lect-7 - Adding BuildConfi, PluginsConfig and ReleaseConfig

Lecture 3 Lect-8 - Adding Build Dependencies

Lecture 4 Lect-9 - Adding Build Test Dependencies

Section 2: Adding Different Build Types, Flavour Types and App Dimentions

Lecture 5 Lect-10 - Adding Build Types,Flavour Types and App Dimentions

Lecture 6 Lect-11 - Add configuration in build gradle of build src

Lecture 7 Lect-12 - Adding Implementation of Sealed Class of Build Types

Lecture 8 Lect - 13- Override Build Types in Application Build Gradle

Lecture 9 Lect -14 - Add App Dimentions and Flavors

Lecture 10 Lect -15 - Add Google, Huawei, Client and Driver Flavors

Lecture 11 Lect-16 - Adding Directory for Each Build Type

Lecture 12 Lect-17 - Start Adding Signing configuration

Lecture 13 Lect-18- implementation of Rlease, ReleaseExternalQa and Debug Siging

Lecture 14 Lect -19 - Adding a Credentials File for Secure Storage of Sensitive Information

Lecture 15 Lect-20- Update Signing Configs with the Data From Local Credentials File

Lecture 16 Lect-21- Test Siging Config

Lecture 17 Lect-22- Refactor Build Creator

Lecture 18 Lect-23- How to Add Build Parameters to Build Configuration

Lecture 19 Lect-24- Test adding Build Parameters to Build Configurations

Lecture 20 Lect-25- Re-Organise Build Src Module

Section 3: Adding Features Module

Lecture 21 Lect-26- Add Features Module

Lecture 22 Lect-27- Add More Dependencies, Room, Hilt, Retrofit and Okhttp

Lecture 23 Lect-28- Changes on Whole App Build Gradle Files

Lecture 24 Lect-29- Make Dependencies Shared Over Modules

Lecture 25 Lect-30- Add Dependencies in Feature Module and App, one Time

Lecture 26 Lect-31- Test Dependencies In App Level and Login Feature Module Level

Section 4: Unlocking the Power of Custom Plugins: Beyond the Basics

Lecture 27 Lect-32- Create Shared Library Gradle Plugin

Lecture 28 Lect-33- Continue Creating Shared Library Gradle Plugin

Lecture 29 Lect-34- Test Shared Library Gradle Plugin

Lecture 30 Lect-35- Add Build Types to Shared Library Gradle Plugin

Lecture 31 Lect-36-Add Koltin Lint Plugin (KTLINT) to App Level

Lecture 32 Lect-37-Continue Add Koltin Lint Plugin (KTLINT) to Modules Level

Lecture 33 Lect-38- Add Spotless and Prettier Plugins

Lecture 34 Lect-39-Continue-Add Spotless and Prettier Plugins

Lecture 35 Lect-40- Add Detekt Plugin: Static Code Analysis Tool

Lecture 36 Lect-41- Detek How to Suppress Legacy Code

Lecture 37 Lect-42- Detekt Reports for App and Modules

Lecture 38 Lect-43- Separate Detekt Reports for App and Modules

Lecture 39 Lect-44-Updating-Build-Versions-with-Ease

Lecture 40 Lect-45- Generate Updating Build Versions Report

Lecture 41 Lect-46-Integrate-with-Dokka-Plugin-for-Code-Documentaion

Lecture 42 Lect-47- Run-Dokka-Plugin-for-Code-Documentaion

Lecture 43 Lect-48-Separating Dokka Reports for App and Modules

Section 5: Tuning Modules Configurations

Lecture 44 Lect - 49 - Add Core Module with Data, Domain and Presemtation Modules

Lecture 45 Lect-50- Configure Plugins and Dependency Provider with Core Modules

Lecture 46 Lect-51- Kickoff Hilt Dependency Injection Setup

Section 6: Core Network Integration in Clean Architecture and Multi-Modular Design

Lecture 47 Lect-52- Implementing Custom Request Headers with OkHttp Interceptors

Lecture 48 Lect-53- Intercept Http Request

Lecture 49 Lect-54- Dependency Injection and Networking: Configuring OkHttp with Hilt

Lecture 50 Lect -55- Integrating and Configuring Http Logging Interceptor

Lecture 51 Lect -56- Building an OkHttp Client with Dagger-Hilt

Lecture 52 Lect-57- Add More Dependencies in Network Module

Lecture 53 Lect-58- Designing an OkHttpClient Provider Interface for Flexible Networking

Lecture 54 Lect-59- Handling SSL and Dispatcher in a Debug OkHttpClient Provider

Lecture 55 Lect-60- Securing Network Requests with Certificate Pinning in OkHttpClient

Lecture 56 Lect-61- Update Http Factory and Network Module with Custome Http Clinets

Lecture 57 Lect-62- Adding Config Module

Lecture 58 Lect-63- Adding Interceptors Module

Lecture 59 Lect -64- Injecting Retrofit in the Network Module with Dagger-Hilt

Lecture 60 Lect -65- Service Factories with Retrofit, Streamlining API Interface Creation

Section 7: Core vs. Login Module: Networking Integration

Lecture 61 Lect -66- Networt Architecture to Login Module: Handling Responses and Requests

Lecture 62 Lect -67- Adding Retrofit Service Interface to Login Module

Lecture 63 Lect -68- Adding Network Module for Login Data Module

Section 8: Developing Core Network Module Components

Lecture 64 Lect-69- Implementing Network Connectivity Monitoring

Lecture 65 Lect -70- Building a Network Data Source with Service and Monitoring

Lecture 66 Lect -71- Defining Error Handling Models with Data Classes

Lecture 67 Lect -72- Building a Flexible Result Wrapper with Success and Error States

Lecture 68 Lect -73- Continue Updating Result Class

Lecture 69 Lect -74- Result Patterns, Mapping, Merging, and Handling Complex Scenarios

Lecture 70 Lect -75- Creating DataSource Interface of HTTP Codes for Network Responses

Lecture 71 Lect -76- Dynamic Response Processing with performRequest in Network Data Source

Lecture 72 Lect -77- Effective Error Handling: Mapping ErrorResponse to Domain Models

Lecture 73 Lect -78- Adding performRequest implementation

Lecture 74 Lect -79- Continue Adding performRequest implementation

Section 9: Module Network Implementation: Remote Implementer, Domain and more

Lecture 75 Lect -80- Implementing Remote Login with Data and Domain Layers

Lecture 76 Lect-81- Adding Network Data Sources in Login Module Using Dependency Injection

Lecture 77 Lect -82- Add Implementation of Remote Implementer

Lecture 78 Lect -83- Add Login Mapper

Lecture 79 Lect -84- Managing Coroutine Execution with Custom Dispatchers

Lecture 80 Lect -85- Verifying App Stability Through a Test Run

Section 10: Mastering Data Persistence with DataStore Module

Lecture 81 Lect -86- Adding Kotlin Serialization and DataStore Dependencies

Lecture 82 Lect -87- Adding Module for Data Store

Lecture 83 Lect -88- Adding AppSettings Data Store class and Use PersistentList for Data

Lecture 84 Lect - 89 - Implementing Custom Serializer for App Settings in Kotlin

Lecture 85 Lect -90- Handle Serialzer Function for App Settings

Lecture 86 Lect -91- Test Data Store Implementation in Real Example

Lecture 87 Lect -92- Adding UI Implementation for Testing

Lecture 88 Lect -93- Running UI Implementation and Fix Issues

Section 11: Advanced DataStore Integration Using Protocol Buffers For Type Safety

Lecture 89 Lect -94- Preferences DataStore Vs Proto DataStore

Lecture 90 Lect -95- Add Proto Buf DataStore Dependencies, Adding Proto DataStore Module

Lecture 91 Lect -96- Modify Gradle for Proto DatsStore Module

Lecture 92 Lect -97- Create Protocol Buffers (Proto) schema for Session and App Preferences

Lecture 93 Lect -98- Create Session Serializer

Lecture 94 Lect -99- Create App Preferences Serializer

Lecture 95 Lect -100- Configuring DataStore with Protocol Buffers and Custom Serializers

Lecture 96 Lect -101- Create Preferences DataStore Manager

Lecture 97 Lect -102- Create Preferences DataStore Manager Implementer

Lecture 98 Lect -103- Create Session DataStore Manager

Lecture 99 Lect -104- Create Session DataStore Manager Implementer

Lecture 100 Lect -105- Dagger-Hilt and DataStore Integration for Preferences and Sessions

Lecture 101 Lect -106- Test Proto DataStore Implementation

Lecture 102 Lect -107- Update App with Session and Preferences DataStore Managers

Section 12: Mastering Interceptor Patterns for Advanced Networking

Lecture 103 Lect -108- Simplifying Network Debugging with Chucker for HTTP(S) Inspection

Lecture 104 Lect -109- Implementing Chucker Interceptor

Lecture 105 Lect -110- Implement Session Service for Token Management and Logout Operations

Lecture 106 Lect -111- Develop Authentication Interceptor with Token Refresh and Mutex Synch

Lecture 107 Lect - 112- Handle Unauthorized Tokens and Retry Requests with Mutex-Protected

Lecture 108 Lect -113- Provide an Authenticator Interceptor with Dependency Injection

Lecture 109 Lect -114- Update Header Interceptor After using Authentication Interceptor

Lecture 110 Lect -115- Implementing a Connectivity Interceptor

Section 13: Domain Layer: Core Business Logic and Use Cases

Lecture 111 Lect -116- Update Error Response Mapper and Model

Lecture 112 Lect -117- Handling Asynchronous Operations with AsyncUseCase

Lecture 113 Lect -118- Implementing LoginUseCase for User Authentication

Section 14: Presentation Layer: Handling State, Error Handling, Inputs, Outputs, Validation

Lecture 114 Lect -119- Implementing Login Activity and Login View Screen

Lecture 115 Lect-120- Update Dependencies with Compose

Lecture 116 Lect -121- Implementing a Login Screen with Jetpack Compose

Lecture 117 Lect -122- Test Login Screen Implementation

Lecture 118 Lect -123- Implementing Error Handling for Login Validation

Lecture 119 Lect -124- Structuring Login Flow with Input and Output Sealed Classes

Lecture 120 Lect -125- Handling Login State and Validation with LoginViewState

Lecture 121 Lect -126- Developing Login Validation Rules with LoginValidator

Lecture 122 Lect -127- Managing Login Inputs and State with ViewModel

Lecture 123 Lect -128- Handling Login State Changes and Validation

Lecture 124 Lect -129- Integrating ViewModel and Compose for Login Screen

Lecture 125 Lect -130- Reacting to State Changes: Collecting ViewModel Outputs

Lecture 126 Lect -131- Executing Login Use Case

Lecture 127 Lect -132- Adding Gson Converter Factory and Make App Updates

Lecture 128 Lect -133- Creating Mock API for Login API

Lecture 129 Lect -134- Test Login Implementation

Section 15: Presentation Layer: Advanced State Management in Compose: Using StateRenderer

Lecture 130 Lect -135- Demo for Popup Loading State with Popup Error State with Retry Option

Lecture 131 Lect -136- Demo for Full Loading State with Full Error State with Retry Option

Lecture 132 Lect -137- Demo for Empty State

Lecture 133 Lect -138- Setup Gradle of Core Presentation Module

Lecture 134 Lect -139- Unified UI States Content, Loading, Error, and Success-States

Lecture 135 Lect -140 -Implementation of Content, Loading, Error, and Success States

Lecture 136 Lect -141- Composable UI State Handlers for State Renderer

Lecture 137 Lect -142- Rendering Complex UI States

Android Developers Seeking to Improve Architecture Skills:,Developers Looking to Master Multi-Modular Projects,Engineers Interested in Advanced Dependency Injection Techniques:,Professionals Focusing on Networking and API Integration,Developers Looking to Improve Code Quality and Automation,Developers Preparing for Senior Roles,Teams Adopting Clean Architecture and Modularization:,Android Developers in Enterprise Environments,Developers Interested in Modern Android Development (MAD) Skills,Developers Preparing for Android Interviews,Developers Focusing on Code Maintainability and Legacy Code Refactoring:,Developers Aiming for Long-Term Code Quality and Performance,Educators and Mentors in Android Developmen