Mastering Multi-Modular & Clean Architecture in Android

Set up a build source gradle module for a multimodular clean architecture, enable Kotlin DSL, and centralize versions to share dependencies across app and submodules.

Migrate Gradle scripts from Groovy to Kotlin, configure build plugins, and create release and test build configs for a multi-modular Android project using kotlin dsl.

Add and centralize build dependencies for the app by creating a dependencies versions file, updating the build.gradle, and aligning AndroidX core, lifecycle runtime, Kotlin, JUnit, Espresso, Compose, and Material3.

Add and organize test dependencies in the app build.gradle using a BuildSrc object for JUnit, Espresso Core, and Compose UI Test.

Learn to add build types and flavor dimensions in Gradle, support Google and Huawei stores, and manage client and driver app variants in a single project.

Configure buildSrc Gradle by adding google repository and dependencies for Kotlin Gradle plugin and Android tools build Gradle; fix project-level plugins, sync, and verify the app runs before next session.

Override application build types in build.gradle using get by name or create, apply sealed class configurations for minify, test coverage, and debuggable, and support types such as release external qa.

Add flavor dimensions and product flavors to your Android project, defining dimensions and creating library and application flavors for each module using a domain object container pattern.

Add google, huawei, client, and driver flavors for app and library modules, configure app and store dimensions, set applicationIdSuffix and versionName, and generate build variants (debug, release, external qa).

Add a directory per build type and flavor to dynamically configure app data, using Android resource directories for Google and Huawei variants with flavor-specific strings and data providers.

Set up and implement signing configurations for an Android project by defining signing types (debug, release, release external QA) and wiring a domain object container into the build.gradle signing configuration.

Continue implementing build signing by creating signing configurations for release, release external qa, and debug, including keystore path, store password, key alias, and v1 and v2 signing settings.

Configure signing for all build types in gradle by using a secure credentials file and local properties. Exclude dev_credentials.properties from source control and read values by name with an extension.

Update signing configs by reading release credentials from a local property via a project interface, replacing hard-coded values with local property extensions, and configure debug and qa keystores.

Test signing configuration by syncing the project, correcting properties, and exporting signed apks and bundles across flavors for qa and production releases.

Refactor the build configuration by introducing a sealed build creator and moving signing and build type logic to the module, enabling debug, release, and external QA builds with signing.

Add build parameters to the Android build configuration using extension functions to generate BuildConfig fields for base URL, database version, map key, and clear cache.

Explore how to add and test build parameters in configurations, configuring base URL, database version, map key, and cache controls across debug and release variants, including signing.

Organize the build source module by creating dedicated folders (build, dependencies, extensions, flavors, plugins, signing, test), moving files, updating imports, and syncing to ensure a clean, working Android project.

Create a features module and add login and home as Android libraries, using a shared build source dependency to enable a modular Android architecture.

Add shared dependencies across modules, including retrofit, Okhttp, room, and Hilt, and define version constants for reuse. Configure build plugins for Android application and Hilt support.

Configure a multi-modular Android project by adding Android and Kotlin plugins, updating plugin portal and Gradle, and applying Android library, Kotlin Android, kapt, and Hilt to modules for shared dependencies.

Explore sharing dependencies across modules in a multi-modular Android project with extension functions and a dependency provider, enabling centralized management of retrofit, room, and hilt.

Centralize dependencies across modules with a build dependency provider for the app and login feature. Add android x, retrofit, hilt, and test dependencies, ensuring clean builds and avoiding circular dependencies.

Validate test dependencies across the app and login feature module by wiring room database access, then asserting room.databaseBuilder usage in the main activity and test fixtures.

Create a shared library Gradle plugin to reuse Android library configurations across modules, reducing duplication for features like login and home by centralizing plugin and Kotlin options.

Continue configuring a custom shared library gradle plugin by updating android blocks, extensions, library extension, and dsl, apply the plugin, and align compile sdk, min sdk, flavors, and build features.

test implementation of the shared library gradle plugin in a multi modules android project, exploring build variants, flavors, and dimensions, and applying plugin id changes and build types across modules.

Configure build types for a shared library Gradle plugin, adding library build types alongside application types, update signing configs, resolve compose compiler and Kotlin version issues, and verify variants.

Add the ktlint plugin to the Android project to enforce consistent Kotlin code formatting and run ktlint format as a pre-build task to prevent style conflicts in pull requests.

Apply the Kotlin lint (ktlint) plugin at the module level, configure editor config rules for Kotlin, fix wildcard imports, and enforce formatting with get lint for clean multi-modular Android architecture.

Leverage spotless and prettier plugins to format Kotlin, Java, XML, and frontend files like JSX, TypeScript, CSS, and JSON, with spotless settings configured in Gradle and synced across modules.

Learn to configure spotless and prettier plugins to format XML, JSON, Kotlin, and Java across an Android project, with Gradle setup, task automation, and prebuild checks.

Integrate detekt, a static code analysis tool, into the Android project to analyze Kotlin code, configure rules and baselines, and generate reports to identify and suppress legacy violations.

Suppress legacy code violations detected by detector and update the baseline for a clean build. Learn to adjust function naming and pattern checks, then run and sync to verify fixes.

Configure detekt to produce separate baseline and report files for app and each module (login, home, core), run analyses, and adjust exclusions to manage violations across modules.

Implement a separation of detekt reports for the app and login module by introducing per-project baselines and module-specific reports, updating plugins and configuration for clean, independent results.

Learn to build a custom gradle plugin that detects new dependency versions and updates them, using buildSrc, a dependency update plugin, and an HTML report.

Learn to generate a dependency updates report by excluding non stable versions, using a Gradle task to compare latest and current dependencies and view stable versus outdated versions.

Integrate the Docker plugin to generate documentation for your Kotlin code and source files. Configure Gradle dependencies, define the docs directory, sync the project, and test the output.

Run the dockerHTML Gradle task to generate code documentation with the Docker plugin; a doc directory with index.html appears, showing login docs and plans for module docs in next lecture.

Learn to separate Dokka reports per module using the Docker plugin, configuring distinct docs directories for app, login, home, and analytics, then generate and view the html documentation via Gradle.

Create an Android library core module that serves as a shared foundation and contains data (network), domain, and presentation modules. Ensure login, app, home, and features modules depend on it.

Configure plugins and the dependency provider for data, domain, and presentation modules, add core baselines for each module, and verify the detect configuration with a project sync.

Kick off the Hilt dependency injection setup by configuring and syncing Hilt dependencies across build source and app modules, including Hilt compiler and navigation, using Java port for generated sources.

Implement a dynamic header interceptor with OkHttp to automatically add authorization, language, and client headers in the Android network layer of a clean architecture project.

Interception of http requests through a header-enriched interceptor, adding authorization, accept, content-type, and language headers with null-safe access token handling for Android architecture.

Configure the network module with Hilt dependency injection and a header interceptor. Provide a singleton header interceptor and prepare for upcoming http logging and http factory integration.

Add an HTTP logging interceptor to reveal API call details in debug mode, including request and response data, while redacting sensitive headers in non-debug builds to protect security.

Learn to build an OkHttp client with dagger-hilt by creating an HTTP call factory, adding interceptors, enabling retry on connection failure, and configuring redirects and connect, read, and write timeouts.

Learn how to extend the network module by adding client id, access token, and language providers, tag them with named annotations, and wire them into header and http login interceptors.

Design and implement an OkHttp client provider interface for a modular Android app, supporting safe release and unsafe debug providers with certificate pinning and build-time configuration.

Implement a debug HTTP client provider to manage a dispatcher and SSL handling, bypassing certificate validation for non-release builds while preserving the release configuration.

Implement SSL pinning for the OkHttpClient by configuring the HTTP client builder, dispatcher, and certificate banner, and organize release, debug, and release qa directories for consistency.

Update the network module by adding a custom http client provider, binding the http client interface, and configuring build variants with http and header interceptors for debug and release modes.

Add a config module to the network module, introducing constants and dependency-injected providers for language, access token, and client ID tags, within a multi-modular Android clean architecture.

Create an interceptors module by renaming the network module, remove config-module dependencies, keep header and login interceptors, and strip http client, factory, and unused imports for a cleaner network module.

Inject Retrofit into the network module with Dagger-Hilt by providing a singleton Retrofit instance, configuring an HTTP client, a coroutine adapter factory, and a base builder for network calls.

Learn to implement a generic service factory that uses retrofit to create a specific service interface instance, enabling login, home, and notification modules via dependency injection.

build the login module in a clean architecture Android project, creating a login request body with username and password and a login response with id, full name, email, and photo.

Define a Retrofit login service interface in the login module, with login api and forget password api, using serialized login request and response models and a base url.

Add a network module for the login data module, wiring a retrofit login service with a service factory and dependency injection to enable cross-module communication between login, data, and core.

Implement a core network monitor to check internet connectivity before API calls, using connectivity manager and network capabilities (wifi, cellular, ethernet), and show a no-network error when offline.

Continue updating the outcome class to support success, error, and empty states for Android clean architecture, including companion object helpers and a use case demo in the login module.

Explore extension functions for the outcome class, including do on success, do in empty, and do in error, plus mapper and merge patterns for parallel API calls.

Create a data source interface with a companion object listing http status codes for network responses, including 200, 400, 401, 404, 409 and codes for no internet, timeout, ssl pinning.

Implement a suspend function performRequest in the network data source to execute service requests and return an outcome, handling on success, on error, on redirect, and on empty.

Map error responses from the network data source to domain error messages using extension functions, with a default fallback and robust json parsing to support presentation and data layers.

Implement performRequest with a connectivity check, error handling, and try-catch for failures, mapping to error codes and default responses, and prepare localization ready messages for the presentation layer.

Continue adding performRequest implementation to handle http responses, success, redirects, and errors in a multi-modular clean architecture Android network data source, with detailed error handling and redirection logic.

Develop the remote login flow by defining a login remote interface and its implementer, map the login response to a domain user model, and prepare data-to-domain mapping for nullable fields.

Configure a dependency injection to provide the login module's network data source by wiring the login service, JSON, network monitor, and user ID provider to the login remote implementer.

Add the login function implementation in the login remote implement, handling request, on success, and on error in the network data source, including mapping to a user object.

Add a login mapper to convert login responses to a user object using domain and model layers, with an interface and implementer. Use a dispatcher for CPU-bound mapping.

Create a coroutine module that provides the default, main, and io dispatchers and injects them into the login mapper.

Verify app stability by running the app after changes and fixing a crash from missing Android X work runtime. Add correct dependency, commit formatting changes, and prepare for datastore implementation.