bufferapp/clean-architecture-components-boilerplate

This is an Android application boilerplate built on Clean Architecture principles, structured into distinct layers for domain, data, and presentation. It manages 'Bufferoo' entities by coordinating local caching with Room, remote API calls via Retrofit, and UI state handling in the mobile layer. The system provides a complete template for asynchronous data flow, dependency injection with Dagger2, and comprehensive testing across all architectural layers.

The domain layer now includes two new interfaces: PostExecutionThread, which abstracts RxJava Schedulers to manage execution context (e.g., switching from background to UI threads), and ThreadExecutor, which provides a standard Java Executor for asynchronous task execution.

domain/src/main/java/org/buffer/android/boilerplate/domain/executor · high confidence

Introduced a new remote data layer to fetch and map Bufferoo data from the API. This includes a Retrofit-based service interface (BufferooService) that calls the /team.json endpoint, a factory (BufferooServiceFactory) to configure the HTTP client and Gson converters, and an implementation (BufferooRemoteImpl) that maps the remote response into domain entities using a dedicated mapper (BufferooEntityMapper). The change also adds the necessary model classes (BufferooModel, BufferooEntity) and unit tests for the remote implementation and mapper.

remote/src · high confidence

The domain layer now includes new base classes for handling asynchronous operations using RxJava2. Specifically, it introduces abstract use-case templates (CompletableUseCase, FlowableUseCase) that manage thread execution via ThreadExecutor and PostExecutionThread, alongside base observer classes (BaseFlowableObserver, BaseSingleObserver) to simplify observer implementation. A concrete use case (GetBufferoos) is also added to retrieve a list of Bufferoo items, demonstrating the new architecture.

domain/src/main/java/org/buffer/android/boilerplate/domain/interactor · high confidence

Added a new data module that provides a repository implementation for 'Bufferoo' entities, supporting both local cache and remote data sources. This includes a data repository that coordinates between cache and remote stores, a mapper for converting between domain and data models, and a factory to select the appropriate data store based on cache status. The change also introduces a thread executor for background job processing and includes comprehensive unit tests for the repository, mappers, and data stores.

data · high confidence

The repository was initialized with a comprehensive set of documentation files, including a detailed README explaining the Clean Architecture boilerplate, a MIT license file, and a Travis CI configuration for Android builds. Additionally, the Gradle wrapper scripts (gradlew, gradlew.bat) were updated to improve cross-platform compatibility and argument handling, and the .gitignore file was expanded to exclude common build artifacts and IDE files.

(repo-wide) · high confidence

Added a new cache module that implements local data persistence using the Room database library. This includes the database setup, a data access object (DAO) for 'Bufferoo' entities, a cache implementation class that handles save, retrieve, and clear operations, and a preferences helper to track cache timestamps. This provides a local data layer for caching 'Bufferoo' data.

cache/src/main · high confidence

Added the mobile-ui module containing the BrowseActivity, which displays a list of items in a RecyclerView with support for loading, empty, and error states. The implementation includes the corresponding layout files, custom widgets for empty and error views, and a Dagger2 dependency injection setup (ApplicationComponent, modules) to wire the presentation layer. Additionally, a comprehensive set of Android instrumented tests and test utilities (TestApplication, TestRunner, mock modules) were added to verify the UI behavior.

mobile-ui/src · high confidence

The presentation module now includes the core UI and data-handling components for the 'Bufferoo' feature. This includes a ViewModel (BrowseBufferoosViewModel) that manages UI state and interacts with domain use cases, a generic Resource wrapper to handle loading, success, and error states, and a mapper to convert domain models to view models. Additionally, unit tests have been added to verify the ViewModel's behavior across different states.

presentation/src · high confidence

A new data class named Bufferoo has been added to the domain layer, representing an entity fetched from an external data source. This model includes fields for id, name, title, and avatar, establishing the structure for domain-level data handling.

domain/src/main/java/org/buffer/android/boilerplate/domain/model · high confidence

A new BufferooRepository interface is added to the domain layer, defining methods to clear, save, and retrieve a list of Bufferoo objects using RxJava types (Completable and Flowable). This establishes the contract for data operations, allowing the domain layer to interact with the underlying data source through a defined API.

domain/src/main/java/org/buffer/android/boilerplate/domain/repository · high confidence

The Gradle wrapper has been updated to use the full release of Gradle 4.1, replacing the previous milestone 1 build. This change ensures the project uses a stable, non-preview version of the build tool, which may improve build reliability and compatibility with other dependencies.

gradle · high confidence

Added new unit tests for the cache implementation, including tests for the BufferooCacheImpl, CachedBufferooDao, and BufferooEntityMapper, along with supporting test factories and configuration.

cache/src/test, domain/src/test · high confidence

The project has been restructured from a single app module into a multi-module architecture, introducing new modules for cache, data, domain, presentation, remote, and mobile-ui layers. This change updates the Gradle build configuration to include these new modules and integrates a range of updated libraries, including Kotlin 1.1.51, Gradle 3.0.0-rc1, and various AndroidX and third-party dependencies such as Dagger 2.11, Retrofit 2.3.0, and Espresso 3.0.0.

(dependencies) · medium confidence

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

• CAI 56 → 51 (-4.1)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 100 → 100 (+0.0)
• Architecture 100 → 88 (-11.9)
• Maturity 65 → 65 (+0.0)
• Readiness 57 → 41 (-16.2)
• Security 100 → 100 (+0.0)
• Domain Modelling 38 → 40 (+2.0)

• 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
• dormant codebase — no living knowledge left to concentrate

• 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 usage examples (README.md)
• No dependency advisory monitoring

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

bufferapp/clean-architecture-components-boilerplate 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.