KO | EN

GitLite

Minimalist Open Source Repository Search Engine

gitlite — search

#typescript #ai-agents #cli #claude-code #codex #developer-tools #ai #dsh-plugin #ai-agent #mcp #deepseek-harness #windows

MvvmKotlinJetpackCompose

★ 86 Open GitHub ↗

MVVM + Kotlin + Jetpack Compose +Navigation Compose + Hilt + Retrofit + Unit Testing + Custom hilt annotation for object to a specific flow + Compose Testing + Coroutines + Kotlin Flow + Io mockK +

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

# MvvmKotlinJetpackCompose 🚀
### A Comprehensive Guide to Modern Android Architecture

Welcome! This project is a professional learning template designed to bridge the gap between "writing code" and "designing systems." It demonstrates how to build a robust, testable Android app using Clean Architecture, MVVM, and the latest Jetpack tools.

---

## 🏗 Why do we need an architecture?

Let's say you created a project without any architecture, simply doing everything in the Activity class (e.g., calling APIs, database interaction, parsing logic, etc.). Even if you have separate classes, your Activity handles multiple responsibilities, making it a **God Object**.

**The Problem:** When requirements change (like a UI update), the tight coupling between UI and logic makes changes slow and risky. You might break the API logic while fixing a button. It becomes hard to maintain, difficult to track bugs, and impossible to reuse or test.

**The Solution:** Architecture breaks the system into independent parts that talk to each other through defined rules. This reduces chaos and makes your code **Robust, Extensible, and Testable.**

---

## 🧩 The SOLID Principles

We keep our architecture clean by following these techniques:

### **S - Single Responsibility (SRP)**
*“A class should have only one reason to change.”*
Compare class names with their behaviors. If a method looks "out of place," it belongs elsewhere. In this project, an `Activity` only renders UI, while a `Repository` only fetches data.

### **O - Open/Closed (OCP)**
*“Open for extension, but closed for modification.”*
You should be able to add new features without changing existing code. For example, our `BaseViewModel` provides standard loading logic that any new ViewModel can extend without modifying the base class.

### **L - Liskov Substitution (LSP)**
*“Subtypes must be substitutable for their base types.”*
Well-designed inheritance ensures that if you swap a parent class with a child (e.g., a `RealRepository` with a `TestRepository`), the app continues to function perfectly.

### **I - Interface Segregation (ISP)**
*“Don’t force a class to depend on methods it doesn't use.”*
We split large interfaces into small, specific ones. This keeps our classes lean and prevents them from implementing "empty" methods just to satisfy an interface.

### **D - Dependency Inversion (DIP)**
*“Depend on abstractions, not concretions.”*
High-level logic (UI) shouldn't depend on low-level tools (Retrofit). They both depend on **Interfaces**. This is why we use **Dependency Injection** (Hilt) to wire our app together.

---

## 🧩 Business Rules vs. Presentation Rules

A critical part of Clean Architecture is separating these two:

---

## 🔄 The Data Flow (UDF)

This project uses **Unidirectional Data Flow**. Data only moves in one direction:

---

## 🗺 Project Structure (The Map)

```text
app/src/main/java/.../
├── data/                 # DATA LAYER: Repositories, API (Retrofit), Prefs (DataStore)
├── ui/                   # PRESENTATION LAYER: ViewModels, Compose Screens, Themes
│   ├── base/             # Foundation classes (BaseViewModel, etc.)
│   └── [feature]/        # Feature-based packages (Login, Dashboard, etc.)
├── di/                   # DEPENDENCY INJECTION: Hilt Modules
└── util/                 # THE TOOLBOX: Helpers, Coroutine Dispatchers
```

---

## 🛠 Modern Tech Stack

- **[Jetpack Compose](https://developer.android.com/jetpack/compose)**: Modern declarative UI that reacts to state changes.
- **[Hilt](https://developer.android.com/training/dependency-injection/hilt-android)**: Automates Dependency Injection.
- **[Retrofit](https://square.github.io/retrofit/)**: The industry standard for type-safe networking.
- **[Moshi](https://github.com/square/moshi)**: A modern JSON library for Kotlin that makes parsing seamless.
- **[Coroutines & Flow](https://developer.android.com/kotlin/coroutines)**: Handles asynchronous tasks smoothly.
- **[DataStore](https://developer.android.com/topic/libraries/architecture/datastore)**: A reactive local storage solution.

---

## 🧪 Unit Testing: The Safety Net

Unit testing isn't just about finding bugs; it **enforces good architecture**. If you can't test a class easily, your architecture is likely too "tight."
- **Confidence**: Verify that adding a new feature didn't break old ones.
- **Speed**: Run thousands of tests in seconds without needing an emulator.

---

## 📝 License
This project is licensed under the [MIT License](LICENSE).

MvvmKotlinJetpackCompose

Explore Similar Repositories

Was this content helpful?

Recent Feedback

Download README