Loading repository data…
onkar-c / repository
A production-ready Android app template built with Kotlin and Clean Architecture. This project is meant to be a starting point for real-world apps that need a modular, testable, and maintainable architecture.
A transparent discovery signal based on current public GitHub metadata.
This score does not audit code, security, maintainers, documentation quality, or suitability. Verify the repository and its current documentation before adoption.
A production-ready Android app template built with Kotlin, Jetpack Compose, Clean Architecture, and Dagger 2, using Room as the single source of truth and Retrofit to consume TheMealDB API.
This project is meant to be a starting point for real-world apps that need a modular, testable, and maintainable architecture.
:app – UI, navigation, application startup, DI entry point:domain – pure business models and repository interfaces:data – Room, Retrofit, mappers, repository implementations, data DIDEV / PROD) visible in the UIlookup.php?i={idMeal})AppComponent in :app:data.diThis project follows a variant of Robert C. Martin’s (Uncle Bob) Clean Architecture, adapted to Android.
The core idea:
Business rules should not depend on frameworks, UI, or external data sources.
Instead, frameworks and data sources depend on the business rules.
Selected from shared topics, language and repository description—not editorial ratings.
eslamfaisal /
🍰 Production-ready Android app demonstrating Clean Architecture with multi-module setup. Built with Jetpack Compose, Material 3, MVI pattern, Hilt DI, Retrofit, Room, and Kotlin Coroutines. Perfect for learning enterprise Android development best practices.
75/100 healthAhmadHassan-BTed /
A soulful, production-grade PDF reader for Android featuring a "Warm Paper" aesthetic, gesture-driven interface, and a high-performance modular architecture. Built with Kotlin 2.0 and Jetpack Compose
71/100 healthWe map classic Clean Architecture concepts to modules like this:
| Clean Architecture concept | This project |
|---|---|
| Entities / Business rules | :domain module |
| Use cases / Interactors | (can live in :domain, optional) |
| Interface adapters | :data (repositories, mappers, DAOs) |
| Frameworks & UI | :app (Compose UI, Android, DI) |
All dependencies point inward.
Inner layers don’t know anything about outer layers:
app (UI, Android, DI) → depends on → domain, data data (DB, network, repo) → depends on → domain domain (business rules) → depends on → nothing
:domain has no Android imports and no Room/Retrofit. :data implements interfaces defined in :domain. :app uses the abstractions from :domain and the implementations from :data.
graph TD
subgraph Domain["Domain (:domain)"]
M["Meal model"]
R["MealRepository interface"]
end
subgraph Data["Data (:data)"]
E["Room entities & DAO"]
Dto["Retrofit DTOs"]
Map["DTO <-> Entity <-> Domain mappers"]
Impl["MealRepositoryImpl"]
end
subgraph App["App (:app)"]
UI["Compose UI (Home, Details)"]
VM["ViewModels"]
DI["AppComponent & ViewModelModule"]
end
UI --> VM
VM --> R
Impl --> E
Impl --> Dto
Data --> Domain
App --> Domain
App --> Data
Domain defines what the app needs (Meal, MealRepository).
Data defines how data is fetched/stored (Room, Retrofit) and implements MealRepository.
App wires everything together (Dagger), exposes ViewModels, and renders UI.
:domain)Goal: represent business concepts and contracts, independent of Android.
Contains:
model/Meal.kt – domain model representing a mealrepository/MealRepository.kt – interface defining what operations UI can doConstraints:
:data)Goal: implement the contracts from :domain using infrastructure (DB + network).
Contains:
local/
MealEntity – Room entityMealDao – DAO with queriesAppDatabase – Room databaseremote/
MealApiService – Retrofit API definitionMealDto – DTO matching TheMealDB responsemapper/
MealDto ↔ MealEntity ↔ Meal (domain)strIngredient* and strMeasure* into a multi-line ingredients textrepository/
MealRepositoryImpl – implements MealRepository using DAO + APIdi/
DatabaseModule – provides AppDatabase and DAOsNetworkModule – provides OkHttp, Moshi, Retrofit, and API serviceRepositoryModule – binds MealRepository to MealRepositoryImplResponsibilities:
:app)Goal: Android-specific concerns – UI, navigation, app startup, DI entry point.
Contains:
MainActivity – hosts the Compose content
AndroidCleanArchitectureTemplateApp – Application class that creates AppComponent
navigation/
AppNavGraph – navigation graphpresentation/home/
presentation/details/
presentation/vm/
MealListViewModel)di/
AppComponent – Dagger component that wires everythingViewModelModule – multibinding for ViewModelsResponsibilities:
:domainThis template uses product flavors to manage different environments.
Dimension: env
dev
applicationIdSuffix = ".dev"DB_NAME = "meals_dev.db"BASE_URL for TheMealDB (can be changed to staging/mock)prod
DB_NAME = "meals_prod.db"BASE_URL for productionThese values are defined as buildConfigField in the :data module and used in:
NetworkModule – BuildConfig.BASE_URL → RetrofitDatabaseModule – BuildConfig.DB_NAME → Roomdebug – debuggable builds for developmentrelease – optimized builds for distributionBuild variants:
devDebugdevReleaseprodDebugprodReleaseThe UI also shows the current flavor (DEV / PROD) in a chip on the top app bar.
Top app bar
MealsClean Architecture TemplateDEV or PRODBody
LazyColumn of mealsStates
Top app bar
Body
Hero image (full-width meal thumbnail)
Title + favorite star button
Category and area chips (e.g. Dessert, Uruguayan)
Ingredients section
strIngredient* + strMeasure*Instructions section
External links
Watch on YouTube – opens strYoutubeView source – opens strSourceClone the repository
git clone https://github.com/<your-username>/AndroidCleanArchitectureTemplate.git
cd AndroidCleanArchitectureTemplate
Open in Android Studio
File → Open → select the project root folder.
Open Build Variants tool window.
For app, pick devDebug (recommended for development).
Click Run ▶ and choose a device/emulator.
The app will:
Fetch meals from TheMealDB
Store them in Room
Show them in the home list
Allow navigating to a details screen and toggling favorites
KishanViramgama /
🚀 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.
57/100 healthmoehamade /
Production-ready Android template with Jetpack Compose, Clean Architecture, multi-module setup, Firebase integration, and CI/CD. One-command rebranding included.
51/100 healthNishit79 /
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.
42/100 healthajrajthala /
Production-ready Android chat app with Gemini AI, Jetpack Compose & modern architecture
63/100 health