aminography/WorldCitiesApp

This is an Android application structured around a clean architecture with distinct presentation, domain, and data layers. It provides city and user search functionalities, utilizing pagination and remote APIs for data retrieval. The system is organized into dynamic feature modules for city lists, map viewing, and user lists, all supported by a centralized dependency injection and coroutine infrastructure.

The repository now includes a full Apache 2.0 license file (LICENSE.md) and a comprehensive README.md that outlines the Android app's clean architecture, including its three-layer structure (Presentation, Domain, Data), Gradle module organization, dependency injection with Dagger2, and third-party libraries. This provides users with the legal terms for using the code and a clear understanding of the project's structure and design choices.

(repo-wide) · high confidence

New test support files have been added to the common/sharedAndroidTest module, including an InstantExecutorExtension to synchronously execute background tasks in JUnit 5 tests, and a LiveDataTestUtil to safely await LiveData values in host-side tests.

common/sharedAndroidTest · high confidence

A new keystore configuration file (keystore.properties) has been added to the repository, defining paths and passwords for the debug keystore and key alias.

keystore · high confidence

The city list functionality has been restructured into a new dynamic feature module. This includes the creation of a dedicated \citylist\ directory containing the \CityListFragment\, its associated ViewModels, adapters, and data models, along with the \cities.json\ asset file. The module is configured with an AndroidManifest for dynamic delivery and includes its own Dagger component for dependency injection, separating the city list UI and logic from the main application module.

features/citylist · high confidence

The map-viewer feature is now a dynamic, standalone module with its own AndroidManifest, layout, and UI components. Users can view a city on a map with a title and subtitle, and can navigate to a users list from the map viewer. The feature includes its own Dagger components for dependency injection and a ViewModel that handles navigation and data binding. Tests have been added to verify the ViewModel's behavior.

features/mapviewer · high confidence

Added a new \common/navigation\ module providing a lightweight navigation abstraction for Android. This includes a \NavDirection\ sealed class to represent navigation actions (Up or DeepLink), extension functions on \NavController\ and \Fragment\ to simplify deep-link navigation, and a \DeepLinkNavArgLazy\ utility that decodes Parcelable arguments from deep links using Base64 encoding. The module also includes default slide transition animations for fragment navigation.

common/navigation · high confidence

The user list functionality has been restructured into a dynamic feature module, enabling on-demand loading of the user list screen. This change includes the implementation of the UserListFragment, its associated ViewModel, and a Paging-based adapter to display a list of users with support for pagination, loading states, and error handling. The module also introduces a dedicated Dagger component for dependency injection and includes unit and instrumented tests for the new feature.

features/userlist · high confidence

Added a new SearchUsersUseCase and UserRepository interface to the domain layer, enabling the application to search for users by location. The use case leverages Kotlin coroutines and AndroidX Paging to return a stream of paginated user data, marking the introduction of this specific search functionality.

architecture/domain/src/main/java/com/aminography/domain/user · high confidence

The common module now includes a new 'appCore' component that establishes the application's base structure, including an Android Application class and Dagger 2 dependency injection setup (AppComponent and AppModule) to manage application-scoped dependencies. Additionally, placeholder files (gitignore, consumer-rules) are added for the coroutine, navigation, scope, and test modules, indicating a structural reorganization of the codebase.

common · medium confidence

The common/scope module now provides new scope annotations—AppScope, FeatureScope, NetworkScope, and PersistentDataScope—along with a ComponentHolder utility class that manages singleton component instances. These additions support a refactored dependency injection architecture, allowing components to be scoped to specific lifecycle stages (app, feature, network, and persistent data) and simplifying component retrieval and clearing.

common/scope · high confidence

Added new base classes for domain use cases: BaseUseCase and BaseFlowUseCase, along with the UseCase interface. BaseUseCase provides a standard template for synchronous use cases that return a Kotlin Result, handling execution on a specified CoroutineDispatcher. BaseFlowUseCase provides a template for asynchronous use cases that return a Flow, also executing on a specified CoroutineDispatcher. These classes standardize how use cases are structured and executed within the domain layer.

architecture/domain/src/main/java/com/aminography/domain/base · high confidence

A new city domain layer has been introduced, defining a CityRepository interface and four use cases: LoadCities, SearchCities, SelectCity, and ClearCitiesCache. The repository exposes methods to load city data, perform prefix-based search returning paginated results, clear the cache, and select a city. The SearchCitiesUseCase implements a lowercase search query normalization. An extension property on the City model provides a searchable key combining name, country code, and ID.

architecture/domain/src/main/java/com/aminography/domain/city · high confidence

The common/coroutine module now includes a new SingleRunningJob class that allows running coroutines uniquely by automatically cancelling the previous active job when a new one is assigned. Additionally, the module introduces a Dagger-based dependency injection setup for Kotlin Coroutines, providing injected access to Default, IO, and Main thread dispatchers via the new CoroutineComponent and DispatcherModule. A utility extension function cancelIfActive is also added to safely cancel active jobs.

common/coroutine · high confidence

The data module now includes a complete implementation for city and user search features. For cities, the app uses a RadixTree for efficient prefix search and loads data concurrently. For users, it implements a new data source and repository that fetches and paginates search results from a remote API. Both features are wired via new Dagger modules and use the existing network and persistent data components.

architecture/data/src/main · high confidence

The app's architecture has been reorganized to improve code reuse and navigation structure. New base classes have been introduced: \BaseActivity\ and \BaseFragment\ provide a common mechanism for ViewBinding and lifecycle management, while \BaseViewHolder\ and \BaseDataHolder\ standardize RecyclerView item handling. The main activity now enforces a dark theme by default. Navigation has been split into a main graph (\nav\_graph\_app\) that includes separate graphs for city list, map viewer, and user list features. Additionally, utility classes for handling toasts, keyboard visibility, and live data events have been added to the UI layer.

architecture · high confidence

The default \MainActivity\ and its associated layout (\activity\_main.xml\) have been removed from the app module, along with the default launcher icon drawables and the base color palette and theme definitions. This cleanup removes the initial scaffolding, likely as part of a larger migration to a dynamic feature module structure.

app/src · high confidence

The project's Gradle wrapper has been updated from version 6.5 to 7.0.2. This upgrade brings the underlying build tooling to a newer release, which may affect build performance, compatibility with newer Java versions, and the behavior of Gradle-specific features.

gradle · high confidence

Added shared test utilities and sample data; Added unit tests for domain use cases; Added unit tests for the data layer.

The project has been restructured into a multi-module architecture, introducing new modules for common utilities (appCore, scope, navigation, coroutine), architecture layers (app, data, domain, model), and dynamic features (cityList, userList, mapViewer). Dependencies are now managed centrally via a \versions.gradle\ file and shared Gradle scripts (e.g., \dagger.gradle\, \lifecycle.gradle\), replacing the previous flat dependency declarations. This change improves code organization and allows for more granular control over module dependencies and testing utilities.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 48 → 44 (-3.9)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 100 → 100 (-0.2)
• Architecture 99 → 78 (-20.6)
• Maturity 59 → 65 (+5.9)
• Readiness 12 → 8 (-4.4)
• Security 100 → 95 (-5.0)

• Change coupling: CityListComponent.kt ↔ CityListInjector.kt (features/citylist/src/main/java/com/aminography/worldcities/citylist/di/CityListComponent.kt)
• Coverage not included — suite not readable by the collector
• Dependency hygiene not measured — dependency manifest found but not parsed for hygiene
• No exposed public API
• Test reliability not included
• single-maintainer — knowledge-concentration (bus factor) risk

• Dependency hygiene PARTLY measured — Maven/Gradle declarations read, no dependency graph resolved
• Documentation: no installation or build instructions (README.md)
• Documentation: no usage examples (README.md)
• High secret: WD-SECRET-0004 (keystore/debug.jks)
• Leaked secret: hardcoded-credential (keystore/keystore.properties)
• Leaked secret: private-key-store (keystore/debug.jks)
• No ADRs found
• TodoComment (features/citylist/src/main/java/com/aminography/worldcities/citylist/vm/CityListViewModel.kt)

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

aminography/WorldCitiesApp was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.