A transparent discovery signal based on current public GitHub metadata.
Recent activity35% weight
52
Community adoption25% weight
0
Maintenance state20% weight
100
License clarity10% weight
0
Project information10% weight
75
This score does not audit code, security, maintainers, documentation quality, or suitability. Verify the repository and its current documentation before adoption.
This template uses the MVVM (Model–View–ViewModel) pattern to keep UI, logic, and data clearly separated and easy to test.
View (UI – Compose)
Composables like TasksScreen only render TasksUiState and send user actions (add, toggle, delete, refresh) back to the ViewModel via callbacks. They don’t know about Room, Retrofit, or Hilt.
ViewModel TasksViewModel exposes a StateFlow<TasksUiState>, collects data from , and handles user events using coroutines. It decides the UI should show, but doesn’t know how data is stored or fetched.
ALGORITHMICALLY RELATED
Similar Open-Source Projects
Selected from shared topics, language and repository description—not editorial ratings.
🚀 A modern, production-ready Android template featuring Secure Authentication and Real-Time Chat. Built with Jetpack Compose, MVVM, and Clean Architecture, it integrates WebSockets (Ktor) for instant messaging and Dagger Hilt for dependency injection. Supports both Firebase and SQL backends with a polished Material Design 3 UI.
A modular, scalable, and testable Android application built using Clean Architecture, Kotlin, Jetpack Compose, Coroutines, Flow, Hilt, and MVVM. This template provides a solid foundation for building production‑ready Android apps following best practices.
Model (Domain + Data)
The Domain layer defines Task and the TaskRepository interface.
The Data layer implements that interface (TaskRepositoryImpl) using Room (DAO + entities) and Retrofit (API + DTOs), with mappers converting between DB/network models and domain models.
This structure lets you change the UI, database, or API implementation independently, as long as the contracts (ViewModel + Repository interface) stay the same.
High-level component diagram
flowchart TB
%% LAYERS
subgraph UI_Layer["UI Layer"]
UI_Screen["TasksScreen (Compose)"]
UI_Route["TasksRoute"]
end
subgraph Presentation_Layer["Presentation Layer"]
VM["TasksViewModel"]
end
subgraph Domain_Layer["Domain Layer"]
RepoInterface["TaskRepository (interface)"]
DomainModel["Task (domain model)"]
end
subgraph Data_Layer["Data Layer"]
RepoImpl["TaskRepositoryImpl"]
Local["Room · TaskDao · TaskEntity"]
Remote["Retrofit · TaskApi · TaskDto · JSONPlaceholder"]
end
%% FLOWS
UI_Screen -->|"user actions & UI events"| UI_Route
UI_Route -->|"delegates to"| VM
VM -->|"calls"| RepoInterface
DomainModel --> RepoInterface
RepoInterface -->|"implemented by"| RepoImpl
RepoImpl -->|"read/write tasks"| Local
RepoImpl -->|"sync from API"| Remote
VM -->|"StateFlow<TasksUiState>"| UI_Screen
%% STYLES
classDef ui fill:#E3F2FD,stroke:#1E88E5,stroke-width:1px,color:#0D47A1;
classDef vm fill:#E8F5E9,stroke:#43A047,stroke-width:1px,color:#1B5E20;
classDef domain fill:#FFF3E0,stroke:#FB8C00,stroke-width:1px,color:#E65100;
classDef data fill:#F3E5F5,stroke:#8E24AA,stroke-width:1px,color:#4A148C;
class UI_Screen,UI_Route ui;
class VM vm;
class RepoInterface,DomainModel domain;
class RepoImpl,Local,Remote data;
🏗 Project Structure & Architecture
This template follows a feature-first MVVM structure with layered responsibilities inside each feature.
This template follows a unidirectional data flow from data sources → ViewModel → UI, with Room as the single source of truth.
UI → ViewModel
Composables (e.g., TasksScreen) render a TasksUiState exposed by TasksViewModel.
User interactions (add, toggle, delete, refresh) are converted into events and forwarded to the ViewModel through lambdas.
ViewModel → Domain / Repository
The ViewModel only depends on the TaskRepository interface.
It calls repository methods in viewModelScope coroutines (e.g., add task, toggle completion, delete task, refresh from remote).
It subscribes to TaskRepository.observeTasks() and maps this data into TasksUiState.
Repository → Data Sources (Local + Remote)
TaskRepositoryImpl implements TaskRepository and coordinates:
Local data via TaskDao / TaskEntity (Room).
Remote data via TaskApi / TaskDto (Retrofit + Moshi).
Network responses are mapped from DTOs to entities and written into Room.
The repository never returns raw DTOs or entities to the ViewModel; everything is converted to domain models (Task).
Room as Single Source of Truth
The UI does not read directly from the network.
All task lists are exposed as a Flow<List<Task>> based on TaskDao.observeTasks().
Whenever the local database changes (insert, update, delete, or sync from remote), Room emits a new list, the ViewModel updates TasksUiState, and the UI recomposes automatically.
Error / Loading Handling
Long-running operations (like refreshing from the remote API) are wrapped in coroutines.
The ViewModel updates loading and error fields inside TasksUiState, allowing the UI to show progress indicators or error messages without knowing anything about the underlying implementation.