How baudelioandalon/ultimatetest works
Project type and purpose
• This is a multi-module Android application built with Kotlin & Jetpack Compose.
• It follows Clean Architecture and MVVM, with two main feature sets:
– FreeToGames (modules/games)
– RickAndMorty (modules/rickandmorty)
• There are two shared libraries:
– library/core: core domain logic, base ViewModels, UI helpers, networking abstractions
File structure and highlight architectural choices
• app/ – Android application entry point (MainActivity, Application class, navigation graph)
• modules/games/ and modules/rickandmorty/ – feature modules, each with:
– domain layer (use-cases, models, repository interfaces, navigation definitions)
– data layer (Retrofit/Ktor data sources, Room local datasource, repositories)
– presentation layer (ViewModels + Compose UI screens: Welcome, Home, Details, Edit)
– di packages – Modules that wire up ApiModule, RepositoryModule, UseCaseModule, DatabaseModule
• library/core/ – shared domain abstractions and networking wrapper (Ktor core, ApiResponse, StateApi)
• library/uisystem/ – shared UI components and theming
• buildSrc/ – centralized Gradle configuration (Dependency.kt, Version.kt, AndroidConfig.kt)
Extract insights from the README
• Core technologies: Kotlin Serialization, Hilt-style DI (custom modules), Jetpack Compose, Ktor, Room, Coil, Coroutines.
• Workflows:
– On startup, show a welcome screen.
– Navigate via bottom nav to feature screens (Games or RickAndMorty).
– Each feature fetches paginated JSON from its API, persists to Room, displays via LazyColumn or LazyRow.
– Detail and edit workflows update local DB and re-display.
– Offline support: if no Internet, read from Room; on reconnect, resume API calls.
1. Android Client (app module)
2. Feature Modules (games, rickandmorty)
3. Shared Libraries (core, uisystem)
4. Network Engine (Ktor Core wrapper in library/core)
5. Local Storage (Room database)
6. External Services (FreeToGames API, RickAndMorty API)
• UI layer (Compose screens in app and feature modules) → ViewModel (presentation)
• ViewModel → UseCase (domain layer)
• UseCase → Repository (data layer)
• Repository → { RemoteDataSource (Ktor) ↔ External API ; LocalDataSource (Room) }
• DI Modules tie ViewModel, UseCase, Repository, DataSources together
• Shared libraries (core, uisystem) are dependencies of both feature modules and app
c. Architectural patterns & principles:
• Clean Architecture tri-layer separation: Presentation / Domain / Data
• MVVM pattern in each feature
• Single Activity + Compose navigation graph
• Dependency Injection via manual DI modules (Hilt-style)
• Offline-first approach: fallback from remote to local
d. Technologies & frameworks (annotate each component):
• Kotlin + Coroutines for concurrency
• Jetpack Compose for UI
• Ktor (core wrapper) for network calls
• Room for persistence
• Coil for image loading
• Kotlin Serialization for JSON mapping
Detail is key
• Within each feature, show the three Clean Architecture layers.
• Clearly call out the DI modules that connect layers.