How joker-x-dev/coolmallkotlin works
Project Type and Purpose
• This is a modularized Android e-commerce application (“CoolMall”) built in Kotlin with Jetpack Compose.
• It follows MVVM + Clean Architecture, dividing code into layers (presentation, domain, data) and modules (core, feature, navigation, app entry).
• Purpose: demonstrate a modern Android architecture with complete e-commerce flows (auth, product browsing, cart, orders, feedback, chat, user profile).
High-Level File Structure Analysis
Top‐level directories:
• app/ → Android application entry point
• build-logic/ → Custom Gradle conventions/plugins
• core/ → “Clean” architecture shared modules:
– common: utilities, base UI states/ViewModels, app config, login manager
– data: repository interfaces, DI modules
– database: Room database, DAOs, data sources, DI
– datastore: key-value store (MMKV) data sources, DI
– designsystem: shared Compose components and theme
– model: data models (entities, requests, responses, previews)
– network: Retrofit services, network data sources, interceptors, DI
– result: unified Result wrapper and handler
– ui: shared UI components (cards, lists, scaffolds, loading, etc)
– util: logging, permission, notification, storage, time, toast utilities
• feature/ → One module per business domain (auth, main, goods, order, market, cs, feedback, user, common, launch)
• navigation/ → Centralized navigation/event router logic
• docs/, template/ → Documentation and code templates
Architectural Patterns and Key Technologies
• Architectural style: MVVM + Clean Architecture, modularized by layer and feature
• DI: Hilt for injecting repositories, data sources, database, network clients
• Networking: Retrofit + OkHttp + Coroutines/Flow
• Local persistence: Room (SQLite) + MMKV (DataStore)
• UI: Jetpack Compose + Navigation Compose
• Shared design: custom design system module for consistent theming/components
• Build: Gradle Kotlin DSL with custom convention plugins
Main Components
a. Presentation Layer (Client)
• app module: AndroidManifest, Application.kt, MainActivity + NavHost
• Feature modules: Composable screens + ViewModels
• navigation module: AppNavigator, RouteInterceptor → orchestrates Compose NavController
b. Domain/Data Layer (Core Modules)
• core/data: Repository interfaces & DI modules
• core/network: NetworkDataSource implementations → Retrofit services → external API
• core/database & core/datastore: Local data sources (Room DAOs, MMKV)
• core/model: Data models, requests, responses
• core/result: Result wrapper for success/error handling
c. Shared UI & Utils (Core)
• core/designsystem + core/ui: Reusable UI building blocks
• core/util: Logging, permission, notification, validation
d. External Services & Storage
• Remote API (domain-specific e-commerce endpoints)
• Room database (Cart, Footprint, SearchHistory tables)
• MMKV (AuthStore, UserInfoStore)
Relationships and Data Flows
1. User interacts with Composable Screen in a Feature module
2. Screen sends events to its ViewModel (core/common BaseViewModel → feature ViewModel)
3. ViewModel calls domain repositories (in core/data) injected by Hilt
4. Repository delegates to:
– NetworkDataSource (core/network) → Retrofit → remote API
– LocalDataSource (core/database / core/datastore) → Room / MMKV
5. Data mapped to core/model entities → wrapped in core/result → returned as Flow/LiveData
6. ViewModel exposes UI state → Compose renders UI
7. Navigation events handled by navigation module
Architectural Patterns to Highlight
• Clean separation of concerns: presentation ⇄ domain ⇄ data
• One repository per entity (UserRepository, OrderRepository, etc.)
• DI graph: ApplicationComponent → modules (NetworkModule, DatabaseModule, DataStoreModule, AppStateModule)
• Feature modules depend only on core abstractions, not on each other
• Navigation layer isolating route definitions