Modern Android App Architecture

Define clean code and lay a solid foundation for upcoming chapters by exploring popular design principles, including dry and solid, and apply these principles in practice at chapter end.

Define the goals of clean code, explore key system design principles including dry and solid principles, and finish with six demos of the dry principle and five solid principles.

Examine the goals of system design principles to produce clean, readable, and maintainable code with strong testability, separation of concerns, and adherence to dry and solid practices.

Apply the Kiss principle, keep it simple and avoid overengineering, by breaking problems into smaller subproblems and solving them step by step to improve maintainability.

Apply the single responsibility principle to refactor the demo app's nodes manager and nodes persistence. Group load, save, and delete with persistence and keep share separate, improving testability and readability.

Explore the MVP pattern, where the model provides data, the view renders the UI, and the presenter handles presentation logic and mediates between them to enable testable Android apps.

Discover model-view-intent (MVI): a single immutable state, one-way flow, and a pure reducer that maps intents to new states, with one-off effects.

Explore the MVI pattern by implementing intents, state, and one-time effects in a nodes module, demonstrating load, add, delete, and share actions with snack bar feedback and unidirectional data flow.

Explore VIPER architecture for Android, detailing the five components—view, interactor, presenter, entity, router—each with a single responsibility, interfaces, and testable boundaries that separate the user interface from logic.

See VIPER applied on Android with view, presenter, interactor, and router separation. Explore two features: add node and nodes list, showing interfaces, lifecycle handling, and testable dependencies.

Explore the goals and strategies of clean architecture as defined by Uncle Bob, examine its components, and discuss when to use it with practical use cases.

Explore the goals of clean architecture—development, deployment, operation, and maintenance—to minimize costs, maximize programmer productivity, and leverage modularization with stable interfaces in mobile apps.

Apply clean architecture strategies that keep policies independent from details, enabling flexible technology choices and a cross-platform core. Emphasize vertical and horizontal layering, prudent code duplication, and flexible decoupling modes.

Learn how the UI layer, powered by viewmodels, translates data from the data layer into immutable UI state for rendering, with unidirectional data flow and events via LiveData.

Expose UI state as a time-varying stream using unidirectional data flow, with private mutable and public immutable state, and choose between single or multiple streams for consistency and performance.

Learn to implement layered architecture by restructuring UI, domain, and data layers, exposing UI state via the notes ViewModel, and integrating data sources, repositories, reactive APIs, offline-first, and conflict resolution.

Explore the UI and domain layer changes, including a sealed notes UI state with loading, error, and content, exposed via a state flow, and a new sync use case.

Explore layered architecture principles in a notes app, contrasting with clean architecture. See separation of concerns, data layer via repository, and unidirectional state flow with reactive Kotlin flows.

Explore android architecture components across the ui and data layers, from view binding to lifecycle-aware components like ViewModel and LiveData, plus Datastore, Room, WorkManager, and paging.

Master advanced data binding topics, including binding adapters, two-way binding with inverse adapters, converters, and integration with LiveData and ViewModel for lifecycle-aware UI.

Learn how the lifecycle API becomes lifecycle aware in Jetpack Compose. Use lifecycle owner, state flows, and lifecycle event and start effects to load notes and render content.

Guard UI state across configuration changes and resource constraints with view models and saved state APIs. Persist data to disk when the app closes using room, datastore, or shared preferences.

Compare LiveData and Kotlin flows to manage asynchronous data streams, highlighting lifecycle awareness, threading, backpressure, and transformations, and identify when to use each.

Learn to implement coroutines with Kotlin flows in an Android app using ViewModel and lifecycle scopes, avoid LiveData, and optimize flow collection with hot state flows and lifecycle-aware collection.

Understand the paging library as a multi-layer solution that loads paginated data from network or local storage, with in-memory caching, deduplication, and UI integration.

Discover the navigation controller as the central navigation API that manages the navigation graph and backstack, with remember NavController in Jetpack Compose and findNavController in the view system.

Explore how the navigation controller manages the back stack, pushing destinations on navigate and popping them with navigate up or pop backstack, including save state, inclusive, and single top options.

Discover how the Dynamic Navigator integrates feature models with the navigation component, handling installation and progress UI, while the navigation UI automates top app bar, drawer, and bottom navigation.

Explore dependency injection, decoupling and reusability, and how supplying dependencies from outside enables easier testing with mocks; compare self-creation, service locator, and constructor or field injection.

Explore the service locator pattern as an alternative to dependency injection, where a central locator creates and exposes dependencies to classes on demand, highlighting its decoupling, testing, and scoping trade-offs.

Examine component cohesion and coupling to design maintainable multi-module Android apps. Compare modularization strategies: separation by layer, by feature, and by layer-feature, across multimodal app models with a notes demo.

Apply modularization to the notes app by separating data, domain, and UI layers, adopt Gradle version catalogs, and enable dependency injection with Hilt for decoupled, testable architecture.