EranBoudjnah/CleanArchitectureForAndroid

This system is an Android application named 'Who Am I' that allows users to discover their public IP address and associated geolocation details, such as city, ISP, and time zone. It provides a history feature to save, view, and delete past connection records, persisting this data locally on the device. The application is built using a multi-module Clean Architecture with Jetpack Compose for the UI, Hilt for dependency injection, and extensive instrumentation and unit testing to ensure reliability.

43 changes.

This period established the foundational structure of the 'Who Am I' Android application, implementing a multi-module Clean Architecture with Hilt and Jetpack Compose. It focused on building the core domain and data layers for IP address lookup and history management, while simultaneously developing the Home and History screens. The work also included setting up comprehensive testing infrastructure, including instrumentation and unit tests, alongside architectural refinements for navigation and state management.

10 changes.

This period focused on standardizing the build environment with Java 17 and refactoring mapper classes across the home and history modules for improved naming consistency and clarity. Significant effort was dedicated to expanding unit test coverage for data, presentation, and UI mappers, as well as navigation event handling. The work also included integrating the AboutLibraries library for displaying open-source notices.

Introduced the HistoryViewModel to manage the presentation logic for the new history screen. This component handles fetching saved IP address records, displaying them in a list with an optional highlighted entry, and processing record deletion requests. It coordinates with domain use cases for retrieving and deleting history, mapping domain models to presentation models, and emitting navigation events for the back action.

history/presentation/src/main/java/com/mitteloupe/whoami/history/presentation/viewmodel · high confidence

Users can now view a history of past IP address lookups, with each record displaying the IP address, associated location (city/postcode), and timestamp. The list supports configuration change persistence and allows users to delete individual records directly from the interface. A specific IP address can be highlighted upon entry to draw attention to it within the list.

history/ui/src/main/java · high confidence

This change introduces the data-layer implementation for the connection history feature. It adds the \ConnectionHistoryRepository\ which exposes history records as a Kotlin Flow and supports deleting specific records by IP address. To support this, new mappers (\SavedIpAddressRecordDomainMapper\ and \HistoryRecordDeletionDataMapper\) are added to convert between data models and domain models, along with corresponding unit tests for the repository and mappers.

history/data · high confidence

The application now includes a foundational analytics module that allows for tracking user interactions. This change introduces an \Analytics\ interface with methods to log screen views and custom events, along with a base \AnalyticsEvent\ class for defining event properties. A concrete \BogusAnalytics\ implementation is provided for development, which outputs tracking data to standard output (logcat) rather than sending it to a remote server. Additionally, a specific \Click\ event type is defined to capture button interaction details.

analytics · high confidence

A new LoadingAnimation composable has been introduced in the widget module, providing a scalable, animated circle indicator. This component allows for customization of size, color, and animation speed, and is designed to visually signal loading states within the application's widget interface.

widget · high confidence

Introduced new data classes to support the history screen's user interface. \HistoryViewState\ defines the screen's states, including a loading state and a state displaying a collection of records with an optional highlighted IP address. \SavedIpAddressRecordPresentationModel\ structures individual history entries, exposing IP details such as city, region, country code, geolocation, ISP, post code, time zone, and the timestamp of when the record was saved. Additionally, \HistoryRecordDeletionPresentationModel\ was added to handle the context required for deleting a specific record by its IP address.

history/presentation/src/main/java/com/mitteloupe/whoami/history/presentation/model · high confidence

A new time module has been introduced containing the NowProvider interface and its DefaultNowProvider implementation, which delegates to System.currentTimeMillis(). This provides a standardized way to access the current time in milliseconds, likely to facilitate testing or decouple time-dependent logic from the system clock.

time · high confidence

The application now includes specific domain use cases to manage IP history data. Users can delete individual history records via the new DeleteHistoryRecordUseCase, which handles background execution for the deletion operation. Additionally, the GetHistoryUseCase has been introduced to retrieve the collection of saved IP address records, leveraging a continuous execution model to fetch the history data.

history/domain/src/main/java/com/mitteloupe/whoami/history/domain/usecase · high confidence

The history domain layer now exposes two new repository contracts: GetHistoryRepository, which provides history data as a reactive Flow of SavedIpAddressRecordDomainModel, and DeleteHistoryRecordRepository, which defines the capability to remove individual HistoryRecordDeletionDomainModel entries. These interfaces establish the domain-side API for reading and deleting history records, decoupling the business logic from specific data storage implementations.

history/domain/src/main/java/com/mitteloupe/whoami/history/domain/repository · high confidence

This change introduces the foundational structure for the 'Who Am I' application, including the main AndroidManifest, the Hilt-based dependency injection modules for networking (Retrofit/OkHttp), local persistence (SharedPreferences/Moshi), and core architecture (coroutines/use cases). It also establishes the primary navigation host using Jetpack Navigation3, wiring together the Home, History, and Open Source Notices screens, and defines the Material 3 theme and app icon.

app/src/main · high confidence

This change introduces the foundational data source layer for the application, defining the contracts for retrieving IP address information, connection status, and local history records. It establishes key interfaces such as \IpAddressDataSource\ for fetching the current IP, \IpAddressInformationDataSource\ for detailed geolocation data, and \ConnectionDataSource\ which exposes connection state via Kotlin Flows. Additionally, it defines the \IpAddressHistoryDataSource\ for managing local history records (save, delete, and observe) and introduces the corresponding data models, including \SavedIpAddressHistoryRecordDataModel\ with a \savedAtTimestampMilliseconds\ field, and specific exception classes like \NoIpAddressDataException\ and \RequestTimeoutDataException\ to handle data retrieval errors.

datasource · high confidence

This change introduces the core domain model and use cases for managing connection details. It defines a sealed interface \ConnectionDetailsDomainModel\ to represent states such as \Connected\ (containing IP, location, and ISP data), \Disconnected\, \Error\, and \Unset\. It also adds repository interfaces (\GetConnectionDetailsRepository\, \SaveConnectionDetailsRepository\) and corresponding use cases (\GetConnectionDetailsUseCase\, \SaveConnectionDetailsUseCase\) to handle fetching and saving these details, along with specific domain exceptions for error handling.

home/domain/src/main · high confidence

The HomeViewModel has been introduced to handle the presentation logic for the home screen, including fetching and displaying connection details, saving user connection data, and managing navigation events for viewing history and open-source notices. This component acts as the central coordinator between the UI state and the underlying domain use cases, ensuring that user actions like saving details trigger appropriate state updates and navigation flows.

home/presentation/src/main/java/com/mitteloupe/whoami/home/presentation/viewmodel · high confidence

This change introduces the core data-fetching and storage layer for the application. It adds implementations to retrieve the user's public IP address and detailed geographic information (city, region, ISP, etc.) via remote API services using Retrofit. Additionally, it implements a local data source that persists IP address history records in SharedPreferences, allowing users to view and delete past lookup records.

datasource/implementation/src/main · high confidence

The repository has been initialized with the foundational structure for a Clean Architecture Android sample project. This includes the addition of an MIT license, funding configuration, and a comprehensive README detailing the architectural choices (such as Hilt for dependency injection and Jetpack Compose for the UI). The build environment is configured with an EditorConfig for consistent code formatting, a detekt configuration for static code analysis, and Gradle wrapper scripts to ensure reproducible builds. Additionally, the .gitignore has been updated to exclude build artifacts and default inspection profiles.

(repo-wide) · high confidence

This release establishes the foundational structure of the application. It introduces a ProGuard configuration file for build optimization, a CoroutineContextProvider interface to abstract threading contexts (Main and IO) for coroutine execution, and a base DataException class to standardize error handling within the data layer.

app, coroutine, datasource/architecture · high confidence

Added two new domain model classes to the history module: SavedIpAddressRecordDomainModel, which represents a stored IP address record including geolocation details (city, region, country code, ISP, etc.) and a timestamp, and HistoryRecordDeletionDomainModel, which identifies a record for deletion by its IP address. These models provide the data structure for the history feature's domain layer.

history/domain/src/main/java/com/mitteloupe/whoami/history/domain/model · high confidence

This change introduces the core domain-layer infrastructure, including the \UseCase\ interface and specialized base classes (\BackgroundExecutingUseCase\ and \ContinuousExecutingUseCase\) that handle coroutine execution on background threads and flow collection. It also adds a \UseCaseExecutor\ to standardize execution and exception handling, along with a \DomainException\ hierarchy for consistent error reporting.

architecture/domain · high confidence

This change introduces four new data classes in the home UI model package to support the Compose-based home screen: \HomeViewStateUiModel\ (a sealed interface representing Loading, Connected, Disconnected, and Error states), \ConnectionDetailsUiModel\ (holding IP, geographic, and ISP details with associated icons), \DetailsUiModel\ (a wrapper for a list of key-value pairs with icons), and \IconLabelUiModel\ (a helper class pairing a drawable resource with a text label). These models provide the structured data layer for displaying connection status and detailed information in the home interface.

home/ui/src/main/java/com/mitteloupe/whoami/home/ui/model · high confidence

The coroutine-test module now includes helper classes and functions to simplify testing asynchronous code. A fake coroutine context and provider are available to replace real dispatchers with a no-op context, and a new extension function allows reading the current value from a Kotlin Flow for assertions.

coroutine-test · high confidence

This change introduces the data-layer implementation for managing connection state and history. It adds a ConnectionDetailsRepository that observes connection status and fetches IP information, including automatic retry logic for transient failures, and a ConnectionHistoryRepository that persists connection details to local storage. Supporting mappers handle the conversion between domain models and data models, as well as mapping data-layer exceptions to domain exceptions.

home/data/src/main · high confidence

The home screen now uses a new set of Jetpack Compose components to display connection information and navigate the app. Users will see their IP address in a dedicated card, followed by a details block listing city, region, country, geolocation, post code, time zone, and ISP, each accompanied by a specific icon. The interface also includes distinct views for disconnected and error states, as well as a reusable navigation button component for actions like saving.

home/ui/src/main/java/com/mitteloupe/whoami/home/ui/content · high confidence

The home screen UI now uses a set of new Jetpack Compose widgets to manage content visibility with smooth animations. Connected, disconnected, and error states are displayed via \ConnectedContentContainer\, \DisconnectedContentContainer\, and \ErrorContentContainer\, which use spring-based slide and fade transitions to appear and disappear. A \LoadingAnimationContainer\ handles the loading state with similar animations. The footer now includes \NavigationButtons\ for saving details and viewing history, complete with analytics logging, and a link to open-source notices.

home/ui/src/main/java/com/mitteloupe/whoami/home/ui/view/widget · high confidence

This change introduces a comprehensive set of test utilities and rules for the instrumentation testing layer. It adds a mock web server implementation (MockDispatcher, MockWebServerProvider) to simulate backend responses, including SSL support and WebSocket handling. New JUnit rules (WebServerRule, LocalStoreRule, ScreenshotFailureRule, SdkAwareGrantPermissionRule) manage test lifecycle, local storage, and permission granting. The library also provides new Espresso matchers (WithBackgroundColorMatcher, WithDrawableIdMatcher, ItemAtPositionMatcher), a click-child-view action, and a BaseTest class that orchestrates Hilt injection, idling resources, and ANR handling for Compose and Espresso tests.

architecture/instrumentation-test · high confidence

The UI layer has been restructured to introduce a cleaner separation of concerns for view management. A new \ViewStateBinder\ interface allows explicit binding of view states to \ViewsProvider\ implementations, decoupling state application from the base view logic. \BaseFragment\ and \BaseComposeHolder\ have been introduced as abstract base classes that handle common lifecycle observation, navigation event mapping, and notification presentation, reducing boilerplate in concrete screens. Additionally, a \ScreenEnterObserver\ composable provides a standardized way to execute logic exactly once when a Compose screen enters the composition.

architecture/ui/src/main/java/com/mitteloupe/whoami/architecture/ui/view · high confidence

A new pre-commit hook has been added to the automation directory. This hook automatically runs ktlint on the codebase before each commit, ensuring that Kotlin code style issues are caught early. If ktlint is not installed, the hook will exit with an error, prompting the user to install it. If any style violations are found, the commit will be blocked until the issues are resolved.

automation · high confidence

The Home screen's Compose implementation has been refactored to improve state management and visual feedback. The main \HomeScreen\ composable now explicitly observes the \HomeViewState\ stream and maps it to UI-specific models, ensuring that connection details and error messages are preserved across configuration changes using \rememberSaveable\. The layout has been consolidated into a scrollable column that conditionally renders loading, connected, disconnected, and error states via dedicated widget containers. Additionally, a new \EnterSpring\ utility has been introduced to provide a consistent, bouncy spring animation for screen entry transitions.

home/ui/src/main/java/com/mitteloupe/whoami/home/ui/view · high confidence

The home screen's UI composition is now managed through a new HomeDependencies data class, which consolidates the HomeViewModel, various UI mappers (for view state, connection details, and errors), navigation and notification mappers, and analytics into a single dependency holder. This change centralizes the wiring of components required for the home screen, replacing previous ad-hoc dependency injection patterns with a structured approach that improves code organization and maintainability.

home/ui/src/main/java/com/mitteloupe/whoami/home/ui/di · high confidence

A new sealed interface, HomePresentationNavigationEvent, has been added to define navigation triggers within the home screen presentation layer. This interface specifies three distinct events: viewing the history, viewing open-source notices, and navigating with saved IP address details. The inclusion of a non-nullable String parameter for the saved IP address ensures that this data is always present when the corresponding navigation action is triggered.

home/presentation/src/main/java/com/mitteloupe/whoami/home/presentation/navigation · high confidence

The home screen now uses a structured state management approach via new presentation models. HomeViewState defines the UI states (Loading, Connected, Disconnected, Error), where the Connected state exposes detailed IP geolocation data such as city, region, ISP, and time zone. ErrorPresentationModel categorizes specific failure modes like request timeouts or missing IP address information. Additionally, HomePresentationNotification handles user feedback, specifically notifying when a connection is saved.

home/presentation/src/main/java/com/mitteloupe/whoami/home/presentation/model · high confidence

The presentation module now exposes dedicated interfaces for navigation and notifications, allowing UI components to react to user actions and system events through a unified contract. A new \PresentationNavigationEvent\ interface defines navigation outcomes (such as \Back\), while \PresentationNotification\ serves as the base for UI feedback. These are integrated into \BaseViewModel\, which now exposes \Flow\ streams for view state, notifications, and navigation events, enabling decoupled communication between the view model and the UI layer.

architecture/presentation · high confidence

The Open Source Notices screen has been updated to use the AboutLibraries library for displaying third-party license information. The UI now renders a \LibrariesContainer\ component provided by AboutLibraries instead of a custom implementation, and the screen logs a screen event to analytics upon entry. A new string resource for the screen title has also been added.

opensourcenotices/ui · high confidence

The home UI module now uses a set of dedicated mapper classes to convert internal presentation models into UI-specific models. Connection details are mapped via ConnectionDetailsPresentationMapper and ConnectionDetailsUiMapper, handling data transformation and icon assignment. Error states are mapped via ErrorUiMapper to display localized error messages. Notification events, such as connection saving, are handled by HomeNotificationUiMapper to trigger toast notifications. Finally, HomeViewStateUiMapper maps the general application state (Connected, Disconnected, Error, Loading) to UI models.

home/ui/src/main/java/com/mitteloupe/whoami/home/ui/mapper · high confidence

The home presentation layer's mapper classes have been renamed to improve consistency: \ConnectionStateDomainMapper\ is now \ConnectionDetailsDomainMapper\, and the \To\ prefix has been removed from method names (e.g., \toDomain\, \toPresentation\) for brevity. These changes affect how domain models are converted to presentation states and how exceptions are mapped to user-facing error messages, but the underlying behavior for displaying connection details and errors remains the same.

home/presentation/src/main/java/com/mitteloupe/whoami/home/presentation/mapper · high confidence

The navigation layer has been restructured to decouple navigation events from specific UI destinations. A new \UiDestination\ interface defines a generic \navigate\ method, replacing previous concrete destination types. Navigation logic now relies on \NavigationEventDestinationMapper\, an abstract class that maps \PresentationNavigationEvent\ instances to \UiDestination\ objects using Kotlin reflection. If a specific mapper does not handle an event, it falls back to a generic mapping or throws the newly introduced \UnhandledNavigationException\. This change simplifies the navigation architecture by standardizing how navigation events are translated into user interface actions.

architecture/ui/src/main/java/com/mitteloupe/whoami/architecture/ui/navigation · high confidence

The mapper classes in the history presentation layer have been renamed to remove the 'To' prefix from their class names (e.g., \DeleteHistoryRecordRequestDomainMapper\ instead of \DeleteHistoryRecordRequestToDomainMapper\). This change improves naming consistency and brevity across the codebase without altering the functional behavior of the mappers.

history/presentation/src/main/java/com/mitteloupe/whoami/history/presentation/mapper · high confidence

The notification system now uses a simplified functional interface for UI notifications, where \UiNotification\ is defined as a single-method interface with a \present()\ function. Correspondingly, the \NotificationUiMapper\ has been updated to a generic interface that maps presentation notifications to this new \UiNotification\ type, ensuring compile-time safety for the mapping process.

architecture/ui/src/main/java/com/mitteloupe/whoami/architecture/ui/notification · high confidence

A new convention plugin, project-java-library.gradle.kts, has been added to buildSrc to enforce a consistent Java 17 build environment. This change ensures that any module applying this plugin will automatically use Java 17 for source compatibility, target compatibility, and the compiler toolchain, removing the need for manual configuration in individual build files.

buildSrc · high confidence

Added BaseViewModelTest for simplified ViewModel testing; Added architecture tests using Konsist; Added instrumentation tests for Home, History, and Open Source Notices screens; Added unit tests for ConnectionDetails and ConnectionHistory repositories; Added unit tests for HomeViewModel; Added unit tests for connection details use cases; Added unit tests for data mappers and resolvers; Added unit tests for data source implementations and mappers; Added unit tests for history domain use cases; Added unit tests for history presentation and UI mappers; Added unit tests for home UI mappers and notifications; Added unit tests for navigation event destination mappers; Added unit tests for the History ViewModel.

The project's Gradle wrapper has been updated to use Gradle 9.7.1. This ensures that builds are executed with a consistent, specific version of the Gradle build tool, improving reproducibility and allowing the project to leverage features and fixes available in this release.

gradle · high confidence

The project is initialized with a multi-module structure (app, architecture, home, history, datasource, etc.) and adopts a modern Android development stack. Key dependencies include Kotlin 2.3.0, Android Gradle Plugin 9.4.1, Jetpack Compose BOM 2026.09.00, Hilt 2.59.2, and Navigation3 1.1.7. The build system utilizes the Version Catalog (libs.versions.toml) for dependency management, KSP for annotation processing, and integrates ktlint 14.2.0 and detekt 1.23.8 for code quality. The app targets SDK 37 and requires Java 17.

(dependencies) · high confidence

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

• CAI 64 → 68 (+4.6)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 99 → 100 (+0.4)
• Architecture 99 → 97 (-2.3)
• Maturity 60 → 66 (+5.2)
• Readiness 57 → 57 (+0.0)
• Security 57 → 80 (+22.3)
• Domain Modelling 100 → 100 (+0.0)

• Boundary-crossing change coupling: HistoryNavigationEventDestinationMapper.kt ↔ BaseFragment.kt (app/src/main/java/com/mitteloupe/whoami/navigation/mapper/HistoryNavigationEventDestinationMapper.kt)
• Coverage not included — suite not readable by the collector
• Dependency hygiene not measured — dependency manifest found but not parsed for hygiene
• Duplicated block (6 lines × 2) (home/ui/src/main/java/com/mitteloupe/whoami/home/ui/content/ConnectedContent.kt)
• Duplicated block (6 lines × 2) (home/ui/src/main/java/com/mitteloupe/whoami/home/ui/view/HomeScreen.kt)
• Duplicated block (8 lines × 2) (home/ui/src/main/java/com/mitteloupe/whoami/home/ui/content/DetailsBlock.kt)
• Further orphaned files (smaller)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• No exposed public API
• Off-boarding risk: anonymized user #1
• Test reliability not included

• CI installs an unverified third-party binary (.github/workflows/ktlint.yml)
• Dependency hygiene PARTLY measured — Maven/Gradle declarations read, no dependency graph resolved
• Documentation: no contributor guidance (README.md)
• Documentation: no installation or build instructions (README.md)
• Documentation: no licence statement (README.md)
• Documentation: no usage examples (README.md)
• Duplicated block (6–7 lines × 2) (home/ui/src/main/java/com/mitteloupe/whoami/home/ui/content/ConnectedContent.kt)
• Duplicated block (8 lines × 2) (home/ui/src/main/java/com/mitteloupe/whoami/home/ui/content/DetailsBlock.kt)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• No ADRs found
• …and 2 more

• 25 commits — 25 feature/other, 0 fixes

• gradle/libs.versions.toml — 18 commits
• .github/workflows — 5 commits
• gradle/wrapper — 2 commits

• change: Enable the kernel virtual machine. (#656)
• change: Moved logcat into the tests step, where it exists.
• change: chore(deps): update aboutlibraries to v15 (#633)
• change: chore(deps): update actions/setup-java action to v6 (#654)
• change: chore(deps): update android to v9.3.1 (#642)
• change: chore(deps): update android to v9.4.0 (#652)
• change: chore(deps): update android to v9.4.1 (#661)
• change: chore(deps): update android.navigation3 to v1.1.5 (#638)
• change: chore(deps): update android.navigation3 to v1.1.6 (#645)
• change: chore(deps): update dependency androidx.appcompat:appcompat to v1.8.0 (#646)
• change: chore(deps): update dependency androidx.compose:compose-bom to v2026.08.00 (#647)
• change: chore(deps): update dependency androidx.compose:compose-bom to v2026.09.00 (#659)
• change: chore(deps): update dependency androidx.core:core-ktx to v1.19.0 (#626)
• change: chore(deps): update dependency androidx.fragment:fragment-ktx to v1.9.0 (#648)
• change: chore(deps): update dependency androidx.lifecycle:lifecycle-runtime-ktx to v2.11.0 (#629)
• change: chore(deps): update dependency androidx.tracing:tracing to v2 (#649)
• change: chore(deps): update dependency androidx.tracing:tracing to v2.0.1 (#653)
• change: chore(deps): update dependency androidx.tracing:tracing to v2.0.2 (#657)
• change: chore(deps): update dependency com.google.devtools.ksp to v2.3.11 (#643)
• change: chore(deps): update dependency com.google.devtools.ksp to v2.3.12 (#658)
• …and 5 more

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

EranBoudjnah/CleanArchitectureForAndroid 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.