Clean architecture & SOLID principles for Android in Kotlin

Explore clean architecture as a theory for organizing software with single concerns. See how entities, use cases, interfaces, and presentation layers separate concerns to improve maintainability, scalability, testing.

Explore the four basic clean architecture layers—entities, use cases, controllers/presenters/adapters, and infrastructure—and how their roles, dependencies, and optional layer counts adapt to Android projects.

Explore the five SOLID principles—single responsibility, open-closed, Liskov substitution, interface segregation, and dependency inversion—and apply them to Android architecture for stable, extensible code.

Separate the model, view, and viewmodel to connect data, ui, and business logic. Handle async callbacks with Livedata on Android Jetpack lifecycles.

Build a simple notes app in Android Studio using Room for storage, with create, update, and delete features, organized by clean architecture, solid principles, and mvvm in Kotlin.

Create a kotlin android project with a core module, establish data, repository, and use case packages, and configure gradle dependencies to support mvvm, navigation, and room in a clean architecture.

Identify and implement the innermost data layer by defining a Kotlin data class for nodes, including title, content, creation time, update time, and a database id, with no business logic.

Define a note data source interface with suspend add, get, get all, and remove, then build a note repository that delegates to this interface.

Implement four use cases for notes—add note, get note, get all notes, and remove note—via a note repository using suspend operator functions to enable app data access.

Explore how the Android Jetpack navigation component uses a navigation graph and nav controller to switch between a list fragment and a note fragment, managing back stack and deep linking.

Learn to build a list fragment with constraint layout, a recycler view, a progress bar, and a floating action button to navigate to the create note screen.

Create a note fragment for new or edit notes using a constraint layout with title and content edit texts and a save button, and prepare navigation to connect screens.

Set up a navigation graph to connect the list and node fragments with a go to note action, a long node id argument, and back navigation.

Room provides a compile-time generated abstraction over SQL for local data storage, with entities, DAOs, and a database for insert, update, delete, and query, plus compile-time checks and background-thread access.

Create a Room note entity with a table named note, fields title, content, creation date, update time, and an auto generated id, plus conversions between note and note entity.

Define a Dao interface using Android Room, providing suspend functions to add, get by id, get all notes, and delete notes with on conflict replace.

Create a database service as an abstract RoomDatabase subclass, define the note entity and version, expose a noteDao via an abstract function, and implement a singleton getInstance to route requests.

Implement a room note data source that implements the node data source and maps note models to entities, connecting the core repository to the room database via the note dao.

Create a data class use cases to centralize access to all use cases, exposing add node, get all nodes, get node, and remove node, enabling dependency injection in view models.

Discover how MVVM connects business logic to the UI via the ViewModel and LiveData asynchronously. Learn the simplified ViewModel lifecycle and how lifecycle-aware LiveData manages changes.

Implement the node viewmodel for an Android app using Kotlin, wiring a room-backed repository, coroutines on the IO dispatcher, and live data to signal saved notes.

Attach the note view model to the note fragment, update or create a note from title and content, and save via the view model.

Create an item layout for a notes list using a card view with a constrained title, content, and date, styled via styles.xml and dimension resources.

Develop a notes list adapter in the presentation layer to bind database notes to a recycler view, with a view holder, layout bindings, and a data update method.

Implement the list view model to return all nodes from the database, building on the note view model, and challenge yourself to assemble it for deeper learning.

Implement the list view model for Android in Kotlin, using coroutines and live data to fetch all notes via use cases and expose them for the view.

Initialize the list fragment with a note list adapter and a view model, configure a linear layout manager, observe notes, sort by update time descending, and refresh on resume.

Define a list action interface with onClick(id) to handle node taps, pass the id to the node fragment via navigation, then retrieve the node from the database.

Get a note from the database using its id, update the view model with current note data via live data, and populate the title and content views accordingly.

Add a top-right delete note menu in the node fragment, confirm with a dialog, and trigger the note view model to remove the note via the use case, updating UI.

Decouple code by implementing dependency injection with dagger modules for application, repository, and use cases, wiring a repository to the app context to supply use cases for view models.

Define a Dagger view model component to inject use cases into note and list view models, wiring app, repository, and use cases modules, then build to verify injection.

Demonstrate adding a word counter to a note app with clean architecture, counting words per note and displaying them in the note list, first in core, then UI.

Extend the core module by adding a word count feature for notes, introducing a get word count use case that counts title and content words with a regex split.

Modify the Android UI to display word count for notes by adding a word count view, updating the adapter, and introducing a get word count use case in Kotlin.