How project-unifest/unifest-android works
High-level system type and purpose
• Type: Native Android application (Jetpack Compose, Kotlin)
• Purpose: Display university festival maps, allow stamping/liking booths, manage onboarding & settings, and integrate with Firebase & REST backend.
Main architectural layers and modules
A. Presentation (UI & Feature Layers)
• app module: application entry point (UnifestApplication, Hilt setup, service initializers, manifest)
• feature/* modules: UI screens, navigation, viewmodels for each use case (intro, splash, main, home, booth, festival, map, menu, stamp, waiting, liked-booth, navigator)
• core/ui & core/designsystem: shared Compose components, themes, drawables
B. Domain / Common Layer
• core/common: cross-cutting utilities (error handling, permission dialogs, events, UI text abstraction)
• core/model: plain Kotlin data models (BoothModel, FestivalModel, etc.)
• core/navigation: route definitions and navigation abstractions
C. Data Layer
1. Remote API
• core/network: Retrofit service (UnifestService), request/response models, network DI
• core/data/api: API-facing repository interfaces & data sources
• core/data/impl: default implementations of data sources & repositories, mappers from network entities to models, DI modules (FirebaseModule, RepositoryModule)
2. Local Persistence
• core/database: Room databases & DAOs (LikedBoothDatabase, LikedFestivalDatabase), type converters, DI modules
• core/datastore: DataStore interfaces for onboarding, tokens, settings, recent liked festivals; implementations & DI modules
D. Build & Tooling
• build-logic: custom Gradle convention plugins to standardize module configurations (AndroidApplicationComposePlugin, AndroidLibraryPlugin, Retrofit, Hilt, Room conventions, etc.)
• baselineprofile: generates startup & baseline profiles to optimize cold-start performance
• gradle/libs.versions.toml: centralized library versions
Relationships and data flows
• app → feature modules (via Hilt injection, navigation delegates)
• feature modules → core/ui + core/common for shared UI & utils
• feature viewmodels → core/data/api repositories (interfaces)
• core/data/api ← (via Hilt DI) ← core/data/impl (Default…Repository)
• core/data/impl → core/network (Retrofit) + core/datastore + core/database
• core/network ↔ external REST backend
• core/datastore ↔ Android DataStore (local preferences)
• core/database ↔ SQLite (Room)
• UnifestApplication initializers → Firebase Crashlytics & Messaging
Architectural patterns
• Modularization: each feature in its own Gradle module
• Clean separation of concerns: UI (Compose) / Domain (models & common) / Data (repositories, persistence)
• Dependency Injection: Dagger Hilt across all layers
• Convention-over-configuration: build-logic plugins enforce consistent Gradle setups
• Compose Navigation: type-safe, nested navigation in feature and core/navigation modules
Final checklist
– Note the build-logic layer separately to highlight standardized Gradle conventions