Project Architecture

Project Architecture

Module Dependency Graph

app
 ├── feature:navigation-graph
 │    ├── feature:sample
 │    └── feature:core (shared by all features)
 ├── domain:usecase
 │    ├── domain:repository (interfaces only)
 │    ├── domain:model (pure data classes)
 │    └── domain:core (BaseUseCase, DataState, AppError)
 └── data:remote-data / data:local-data
      └── data:core (BaseDataSource, BaseMapper, ExceptionMapper)
           └── domain:model

Strict Dependency Rules

1. Feature modules depend on: feature:core, domain:model, domain:usecase
2. Feature modules NEVER depend on: data:*, other feature:* modules
3. Domain modules are 100% pure Kotlin (NO android.* imports)
4. Data modules depend on: domain:repository, domain:model, domain:core, data:core
5. feature:core is the ONLY feature module that provides shared base classes

Convention Plugins (build_logic/)

Creating a New Feature Module

1. Copy feature/sample/ as a template
2. Add to settings.gradle.kts: include(":feature:new-feature")
3. Create build.gradle.kts:

plugins {
    alias(libs.plugins.android.feature.compose)
    // alias(libs.plugins.android.test.unit)  // Add if tests needed
}

dependencies {
    implementation(projects.domain.model)
    implementation(projects.domain.usecase)
}

4. Create files: XxxViewModel.kt, XxxScreen.kt, XxxNavigation.kt
5. Register NavGraphBuilder.xxxScreen() in feature:navigation-graph
6. Add implementation(projects.feature.newFeature) in app/build.gradle.kts

Creating a New UseCase

domain/usecase/src/main/java/com/template/domain/
├── usecase/newfeature/
│   ├── GetNewFeatureUseCase.kt       (interface)
│   └── GetNewFeatureUseCaseImpl.kt   (implementation)
└── di/
    └── NewFeatureUseCaseModule.kt    (Hilt @Module with @Binds)

// Interface - extends appropriate base
interface GetXxxUseCase : BaseFlowUseCaseNoParams<Flow<PagingData<Xxx>>>

// Implementation - @Inject constructor
class GetXxxUseCaseImpl @Inject constructor(
    private val repository: XxxRepository
) : GetXxxUseCase {
    override fun invoke(): Flow<PagingData<Xxx>> = repository.getXxx()
}

// DI Module - @Binds interface -> impl
@Module
@InstallIn(SingletonComponent::class)
interface XxxUseCaseModule {
    @Binds fun bindGetXxxUseCase(impl: GetXxxUseCaseImpl): GetXxxUseCase
}

UseCase Base Types

Naming Conventions

Hilt DI Organization

domain/usecase/di/         -> UseCaseModules (@Binds interface -> impl)
data/remote-data/di/       -> RepositoryModules, DataSourceModules, MapperModules
data/local-data/di/        -> DatabaseModule, DaoModule, DataStoreModule
app/di/                    -> AppModule (singletons, app-level bindings)

Data Layer Strategy Pattern

BaseDataSource
├── fetchData()         -> FirebaseDataSourceStrategy  (Firebase Task<T> -> Flow<DataState<T>>)
├── fetchRestData()     -> RetrofitDataSourceStrategy  (Response<BaseDto<T>> -> Flow<DataState<T>>)
├── fetchPagingData()   -> PagingDataSourceStrategy    (Pager -> Flow<PagingData<T>>)
└── requestData()       -> Direct sync wrapper

Error Flow

Infrastructure Exception
    ↓ ExceptionMapper (data:core)
AppError sealed class (domain:core)
    ↓ DataState.Error or caught in FlowCollectionManager
ErrorHandler.getErrorMessageResId() (feature:core)
    ↓
String resource ID -> Toast

Build Flavors

Three product flavors for environment configuration:

Build variant format: assembleDevDebug, assembleStagingRelease, assembleProductionRelease