Mastering Multi-Modular & Clean Architecture In Android

Free Download Mastering Multi-Modular & Clean Architecture In Android
Published 9/2024
MP4 | Video: h264, 1920×1080 | Audio: AAC, 44.1 KHz
Language: English | Size: 14.47 GB | Duration: 19h 52m
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
Homepage

https://www.udemy.com/course/mastering-multi-modular-clean-architecture-in-android/