TheAlisher/Boilerplate-Android

This system is an Android application boilerplate designed to establish a standardized, multi-module architecture for building complex apps. It provides a comprehensive foundation that includes a clean architecture with separated data, domain, and presentation layers, along with centralized build conventions and dependency injection via Hilt. The framework supports core capabilities such as paginated network requests, offline Room database persistence, and robust UI state management, serving as a reusable template for feature development.

5 changes.

The project was established with an initial boilerplate structure and documentation, followed by a significant migration to a multi-module architecture using Kotlin DSL and version catalogs. This period also involved refactoring the app to use Hilt for dependency injection, AndroidX Navigation, and Kotlin, while upgrading the Gradle wrapper and build plugins to modern versions.

15 changes.

This period focused on establishing a standardized Android architecture by centralizing build conventions, database initialization, and core data/presentation layers. It involved implementing foundational utilities for networking, paging, and UI state management, alongside the initial development of the Foo and Bar feature modules.

Introduced the 'Foo' feature, providing a complete implementation including a Room database, Retrofit API integration, and a paginated RecyclerView UI. Users can now view a list of 'Foo' items fetched via paging, with support for offline storage and error handling.

feature/foo · high confidence

This change introduces a set of new base classes in the core presentation module to standardize the app's UI architecture. It adds BaseViewModel for handling network requests and UI state via Kotlin Flows, BaseFragment for managing view binding and common UI state logic, and BaseFlowFragment for Single Activity Architecture navigation. Additionally, it provides BaseDialog and BaseBottomSheet for reusable dialog implementations, and BaseDiffUtilItemCallback for efficient RecyclerView list updates.

core/presentation/src/main/kotlin/com/alish/boilerplate/core/presentation/base · high confidence

This change introduces foundational utilities in the data layer to support data mapping and network operations. It adds \DataMapper\ and \DatabaseMapper\ interfaces to standardize conversions between data and domain models, as well as a \DateSerializer\ for kotlinx.serialization. Additionally, it provides \NetworkUtils\ which configures the Retrofit and OkHttpClient instances (including timeouts and debug logging) and offers helper functions for handling JSON from assets, parsing API errors, and converting files to multipart parts for uploads.

core/data/src/main/kotlin/com/alish/boilerplate/core/data/utils · high confidence

The core domain module now includes foundational types and extensions to support repository implementations. A custom \Either\ type is introduced to handle success and error states, alongside a \NetworkError\ sealed class that categorizes failures such as timeouts, API input errors, and unexpected server issues. To streamline data handling, \RemoteWrapper\ and \RemotePagingWrapper\ type aliases define standard return types for network requests, and new \Flow\ extensions (\mapList\ and \mapPaging\) allow for efficient transformation and caching of list and paging data streams.

core/domain · high confidence

Introduced a new validation layer in the presentation module, featuring a \Validator\ interface and a \ValidationResult\ data class to standardize field checking. This change adds specific validation use cases for email, name, password, phone number, and empty-field checks, along with a password confirmation validator, enabling consistent user feedback for form inputs across the application.

core/presentation/src/main/kotlin/com/alish/boilerplate/core/presentation/validation · high confidence

This change introduces the initial implementation of the Bar feature, establishing a complete architecture from presentation to data. The presentation layer includes a BarFragment and BarViewModel, while the domain layer defines the Bar model, a repository interface, and a FetchBarUseCase. The data layer implements the repository using Room for local persistence (BarDao, BarDBO) and Retrofit for network calls (BarApiService, BarDTO), with Hilt modules configured to bind the repository and provide the API service.

feature/bar · high confidence

This change introduces the initial boilerplate for an Android application, including the Apache 2.0 license, a README with links to architectural articles, and a module graph visualization (GRAPH.md) detailing the dependency structure between core and feature modules. It also updates the .gitignore to standardize IDE and build artifact exclusions and contains a likely error in the gradlew wrapper script where 'java' references were replaced with 'kotlin'.

(repo-wide) · high confidence

The application now includes Dagger Hilt modules to manage core infrastructure dependencies. CoroutineModule provides a singleton CoroutineDispatcher bound to Dispatchers.IO, ensuring consistent background thread usage. NetworkModule exposes the AuthenticatorApiService via the NetworkClient, making the authentication API client available for injection throughout the data layer.

core/data/src/main/kotlin/com/alish/boilerplate/core/data/di · high confidence

A new UIState sealed class has been added to the core presentation layer to standardize how screen states are represented. This class defines four distinct states—Idle, Loading, Error, and Success—allowing views to react consistently to data requests, network errors, and successful responses. The change includes a typealias for StateFlow and helper functions to initialize and reset the state flow within BaseViewModel, providing a structured approach to managing UI lifecycle events.

core/presentation/src/main/kotlin/com/alish/boilerplate/core/presentation · high confidence

Added three new base classes to the core data module: BasePagingResponse, which models paginated API responses with previous/next keys and data; BasePagingSource, which provides a reusable implementation of Android Paging's PagingSource to handle network requests and error mapping for list data; and BaseRepository, which offers helper methods (networkFlow, networkFlowList, pagingFlow, dbFlow) to standardize network requests, error handling (including 422 validation errors and timeouts), and data mapping between DTOs and domain models.

core/data/src/main/kotlin/com/alish/boilerplate/core/data/base · high confidence

This change introduces a new set of Kotlin extension functions and UI components in the core presentation module. It adds asynchronous lifecycle-aware coroutine helpers (launchWithRepeatOnLifecycle, launchAndCollectIn) for safer Flow collection, date formatting utilities, and input validation logic for Material Design text fields. Navigation is enhanced with safe navigation methods, back-press overrides, and activity-level controller access. UI convenience functions for Toasts and keyboard management are added, along with a RecyclerView setup helper. Additionally, a new paging module provides a CommonLoadStateAdapter and ViewHolder to display loading and error states with retry functionality in paginated lists.

core/presentation/src/main/kotlin/com/alish/boilerplate/core/presentation/extensions · high confidence

This change introduces a new set of Gradle convention plugins and configuration classes within the build-logic module to standardize the build environment. It centralizes Android build settings (SDK versions 37, minSdk 30, application ID, and versioning) and JVM toolchain (JDK 21) into \ModuleConfig.kt\. New convention plugins (\android-app-conventions\, \android-library-conventions\, \android-feature-conventions\, and \kotlin-library-conventions\) automatically apply dependencies and plugins such as Hilt, KSP, Kotlinx Serialization, and Navigation Safe Args, while also enabling explicit backing fields for Kotlin libraries. Helper extensions in \VersionCatalogExt.kt\ and \TypesafeProjectAccessorsExt.kt\ provide workarounds to access version catalog libraries and project dependencies from within the build-logic scripts.

build-logic/src · high confidence

The database initialization logic has been moved from the app module to the dedicated db module. This change introduces a new Room database configuration (AppDatabase) with constants for the database name, and establishes a Hilt module (DatabaseModule) to provide the database instance and DAOs (FooDao, BarDao) as singletons using the application context. This centralizes database setup and dependency injection within the db module.

db/src · high confidence

A new \gradle-daemon-jvm.properties\ file has been added to the project to configure the Java Development Kit (JDK) used by the Gradle daemon. This configuration specifies JDK 21 from JetBrains as the vendor and version, and provides download URLs for various operating systems (Linux, macOS, Windows, FreeBSD) and architectures (x86\_64, AArch64). This ensures that the Gradle build process uses a consistent and specific JDK environment, reducing potential issues caused by varying local JDK installations.

gradle · high confidence

The app has been refactored to use Kotlin and Hilt for dependency injection, replacing the previous Koin-based service locator and Java implementation. Navigation is now handled via the AndroidX Navigation Component with a dedicated graph, and the main activity now displays a splash screen using the AndroidX SplashScreen API. The UI theme has been updated to remove the action bar, and the package name has been changed from com.alis.boilerplate to com.alish.boilerplate.

app/src · high confidence

The remote data layer has been reorganized into the core module, introducing a new \NetworkClient\ that manages Retrofit instances and a dedicated \AuthenticatorClient\ for token operations. Token authentication is now handled by \TokenAuthenticator\, which uses a Kotlin \Mutex\ to prevent race conditions during concurrent token refreshes, ensuring that only one request triggers a refresh at a time. The \AuthorizationInterceptor\ has been updated to inject \UserDataPreferences\ directly, allowing it to attach the current access token to outgoing requests dynamically.

core/data/src/main/kotlin/com/alish/boilerplate/core/data/remote · high confidence

The local data layer in core/data now uses standard Android SharedPreferences instead of the deprecated Jetpack Security library. This change introduces a new package structure (com.alish.boilerplate.core.data.local.preferences) containing PreferencesClient, PreferencesConstants, and UserDataPreferences. Users will notice that sensitive data like access tokens and refresh tokens are no longer encrypted at rest by default, relying instead on standard private shared preferences storage.

core/data/src/main/kotlin/com/alish/boilerplate/core/data/local · high confidence

The app's ProGuard configuration has been updated to preserve classes implementing the DataMapper interface and the Parcelable interface (used by Navigation Component Safe Args). This ensures that data mapping and navigation arguments are not obfuscated or removed during the build process, preventing runtime crashes related to reflection or serialization.

app · high confidence

The Gradle wrapper has been updated from version 6.5 to 9.7.0, significantly changing the build tool version used for the project. To ensure reliability and security, the configuration now includes a SHA-256 checksum for distribution validation and sets a network timeout of 10 seconds, while also enabling explicit distribution URL validation.

gradle/wrapper · high confidence

The project has been restructured from a single-module setup into a multi-module architecture, introducing dedicated modules for core data, domain, presentation, database, design system, and specific features (foo, bar). This change replaces the legacy Groovy build scripts with Kotlin DSL (KTS) and centralizes dependency management using a Version Catalog (libs.versions.toml). Build logic has been extracted into a precompiled \build-logic\ convention plugin to standardize configurations across modules. Additionally, the build environment has been upgraded to Android Gradle Plugin 9.3.1 and Kotlin 2.4.10, with performance optimizations enabled via the configuration cache and parallel execution.

(dependencies) · high confidence

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

• CAI 46 → 43 (-2.8)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 100 → 99 (-0.5)
• Architecture 100 → 81 (-19.4)
• Maturity 57 → 58 (+0.5)
• Readiness 15 → 15 (+0.0)
• Security 100 → 100 (+0.0)
• Domain Modelling 70 → 60 (-9.9)

• Dependency hygiene not measured — dependency manifest found but not parsed for hygiene
• No exposed public API
• Small-team knowledge concentration
• The modules graph is a Mermaid diagram that appears to be a stub rather than documentation; it shows no relationships or labels describing what each module does. (GRAPH.md)

• 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)
• TodoComment (core/presentation/src/main/kotlin/com/alish/boilerplate/core/presentation/validation/usecase/ValidatePasswordConfirm.kt)
• TodoComment (feature/bar/src/main/kotlin/com/alish/boilerplate/bar/presentation/BarFragment.kt)
• bus factor 1 — one contributor carries this repository

• 10 commits — 10 feature/other, 0 fixes

• gradle/libs.versions.toml — 6 commits
• (repo) — 2 commits
• (root) — 1 commit
• gradle/wrapper — 1 commit

• change: Merge pull request #267 from TheAlisher/update_dependencies_versions
• change: Merge pull request #268 from TheAlisher/update_dependencies_versions
• change: added org.gradle.tooling.parallel
• change: updated AGP version from 9.2.1 to 9.3.1
• change: updated ConstraintLayout version from 2.2.1 to 2.2.2
• change: updated Dagger version from 2.59.2 to 2.60.1
• change: updated Gradle version from 9.5.1 to 9.7.0
• change: updated KSP version from 2.3.9 to 2.3.11
• change: updated Kotlin version from 2.4.0 to 2.4.10
• change: updated Lifecycle version from 2.10.0 to 2.11.0

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

TheAlisher/Boilerplate-Android 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.