rodrigobressan/android_tmdb_clean_architecture

This is an Android application for browsing and viewing movie details, reviews, and categories. It implements a multi-module architecture that separates concerns into domain, data, and presentation layers, utilizing Room for local caching and Retrofit for remote API access. The system supports both mobile and TV interfaces, featuring user authentication and offline data management.

42 changes.

The project underwent a significant structural refactoring, migrating from a single-app module to a multi-module architecture that separates concerns into base, domain, data, and presentation layers. This period focused on implementing the core data and remote fetching logic for movies and reviews, establishing a clean architecture with dependency injection and comprehensive test coverage.

4 changes.

This period focused on establishing the application's data layer by implementing movie review retrieval and caching mechanisms using RxJava. Simultaneously, the team automated build and deployment processes for mobile and TV apps through new CI/CD scripts, while also introducing utilities for generating random test data.

New scripts are added to automate the build, test, and deployment pipelines for both mobile and TV applications. The CI scripts handle running tests, assembling APKs, uploading to Crashlytics, and executing Firebase Test Lab instrumentation tests for dev, QA, and release build types. Local scripts are also added to install the built APKs onto connected devices via ADB.

scripts · high confidence

The IntroActivity now implements a complete Google Sign-In authentication flow. It initializes Google Sign-In with specific client ID and profile/email requests, handles the sign-in activity result, and exchanges the Google ID token for a Firebase authentication credential to sign in the user. The UI updates to display the current user's display name or an error toast based on the authentication state.

mobile/src/main/java/com/rodrigobresan/sampleboilerplateandroid/intro · high confidence

The TV app module now includes the foundational architecture for the TV interface, including a Dagger-based dependency injection setup (ApplicationComponent and subcomponents for fragments), Room database entities and DAOs for caching categories, movies, and reviews, and base classes for mappers and use cases. This establishes the data layer and presentation scaffolding required to display movie details and lists on TV devices.

tv · high confidence

A new ConnectionStatus interface is introduced to provide a mechanism for checking whether the device is offline, enabling the application to detect network availability.

data/src/main/java/com/rodrigobresan/data/connection · high confidence

The mobile module now uses Dagger 2 for dependency injection, introducing an ApplicationComponent and subcomponents for the Movies and MovieDetails activities. This wiring connects the UI layers to their respective presenters, repositories, and use cases, enabling proper separation of concerns and testability for the movie browsing and detail screens.

mobile/src/main/java/com/rodrigobresan/sampleboilerplateandroid/injection · high confidence

A new DataFactory class has been introduced to provide helper methods for generating random test data, including random UUIDs, integers, doubles, longs, and booleans. This utility simplifies the creation of randomized data objects for use in tests.

data/src/main/java/com/rodrigobresan/data · high confidence

A new DataFactory class has been added to the base module, providing static helper methods to generate random test data for strings, integers, doubles, longs, and booleans. This utility is intended to support unit testing by simplifying the creation of random data objects. Additionally, the .gitignore file was moved from the app directory to the base directory.

base · high confidence

A new JobExecutor class has been introduced to handle asynchronous task execution using a ThreadPoolExecutor. This implementation manages a thread pool with an initial size of 3 and a maximum of 5 threads, utilizing a LinkedBlockingQueue for work items. The executor ensures that null runnables are rejected with an exception, providing a robust mechanism for background job processing within the data layer.

data/src/main/java/com/rodrigobresan/data/executor · high confidence

Introduced three new interfaces in the presentation layer to establish a structured architecture: BasePresenter defines the lifecycle methods (start/stop) for presenters, BaseView provides a generic contract for views to hold a presenter reference, and PresentationMapper defines the contract for mapping domain objects to view models. These interfaces provide the foundational contracts for the presentation layer's interaction with the domain layer.

presentation/src/main/java/com/rodrigobresan/presentation/base · high confidence

Introduced the data layer for retrieving and caching movie reviews. This includes a ReviewMapper to convert between domain and entity models, a ReviewDataRepository to manage data flow, and a ReviewDataStoreFactory that switches between remote and cached data sources based on network connectivity. The implementation uses RxJava for asynchronous operations and supports saving, retrieving, and clearing review data.

data/src/main/java/com/rodrigobresan/data/review · high confidence

Introduced new data source implementations for movies, including a local cache interface and data store (MovieCache, MovieCacheDataStore) to store and retrieve movie entities, and a remote data store (MovieRemote, MovieRemoteDataStore) that fetches popular, now playing, top rated, and upcoming movies from a remote API. This adds the underlying data access mechanisms for movie details and categories.

_data/src/main/java/com/rodrigobresan/data/movie/sources/data\store/local · medium confidence

The remote module now includes the full implementation for fetching movie data and reviews. This includes the \MovieService\ interface defining API endpoints for popular, top-rated, upcoming, and now-playing movies, as well as movie details and reviews. The change introduces data models (e.g., \MovieResponse\, \ReviewResponse\), mappers to convert API responses into internal entities, and repository implementations (\MovieRemoteImpl\, \MovieDetailRemoteImpl\, \ReviewRemoteImpl\) that use these mappers to provide data to the application's data layer.

remote/src/main · high confidence

The app now initializes with Fabric Crashlytics for crash reporting, Stetho for debugging, and Dagger2 for dependency injection. A new UiThread class provides a RxJava scheduler for main-thread execution.

mobile/src/main/java/com/rodrigobresan/sampleboilerplateandroid · medium confidence

Added MovieDataRepository, a new implementation of the MovieRepository interface that handles fetching, saving, and deleting movie data. The repository integrates with a data store factory to retrieve cached or remote data stores, mapping entities to domain models via a MovieMapper. This provides the data layer's concrete mechanism for movie-related operations.

data/src/main/java/com/rodrigobresan/data/movie/sources · high confidence

Added the data layer for retrieving movie details, including a repository that fetches data from a remote source and caches it locally. The implementation includes a mapper for converting between entity and domain models, a factory to select between cached or remote data stores based on connectivity and cache status, and specific classes for local caching and remote data access.

_data/src/main/java/com/rodrigobresan/data/movie\detail · high confidence

The repository was initialized with a complete project structure, including a Travis CI configuration (.travis.yml) that sets up an Android build environment with specific API levels, build tools, and SDK components. The entry also includes a LICENSE.md file (MIT), a README.md documenting the architecture and dependencies, and a .gitignore file updated to exclude build artifacts and IDE settings.

(repo-wide) · high confidence

A new MovieMapper class has been added to map between the MovieEntity and the domain-level Movie model, handling fields such as id, title, rating, poster path, and favorite status.

data/src/main/java/com/rodrigobresan/data/movie/mapper · high confidence

The Movies section now has a dedicated contract interface that defines the communication between the View and Presenter, including methods to show/hide progress, error, and empty states, as well as to display movie lists. A corresponding MovieMapper was added to convert domain Movie objects into presentation MovieView models.

presentation/src/main/java/com/rodrigobresan/presentation/movies/contract · high confidence

The cache module now provides a complete local persistence solution using the Room database. This includes the AppDatabase configuration, Data Access Objects (DAOs), and cache implementations for movies, categories, movie categories, movie details, and reviews. To support this, new mappers have been added to convert between data entities and cached models, and unit tests have been added to verify the cache implementations and mappers.

cache · high confidence

The domain layer now includes new repository interfaces (MovieDetailRepository, MovieRepository, ReviewRepository) and a base use-case class (CompletableUseCase) that standardizes how the app fetches and stores movie, category, and review data. Users will experience more consistent data handling as the app prepares to connect these domain contracts to actual data sources, enabling features like viewing movie details, browsing categories, and reading reviews.

domain/src/main · high confidence

The mobile module now includes essential configuration files to support the application's build and runtime environment. This adds a .gitignore rule to exclude build artifacts, a fabric.properties file for crash reporting, a google-services.json file containing Firebase and Google Play Services credentials for multiple build variants (demo, pro, qa), and a proguard-rules.pro file for code obfuscation. These changes enable the mobile app to integrate with external services and prepare for optimized production builds.

mobile · high confidence

Users can now view a list of movies (popular, top rated, upcoming, etc.) in the mobile app. The new MoviesActivity displays movie sections with titles, ratings, and poster images. Tapping a movie card navigates to the MovieDetailActivity. The implementation includes a BaseMapper interface, a MovieMapper for converting domain models to view models, a MoviesAdapter for the RecyclerView, and a reusable MovieSectionView component that handles loading, error, and empty states.

mobile/src/main/java/com/rodrigobresan/sampleboilerplateandroid/movies · high confidence

The application introduces two new interfaces for managing cached data: CategoryCache for general category operations and MovieCategoryCache for movie-specific category interactions. These interfaces define contracts for saving, retrieving, and clearing cached entities, enabling a more structured approach to data layer caching.

_data/src/main/java/com/rodrigobresan/data/movie\category · high confidence

The movie details section now introduces a formal contract interface defining the view and presenter interactions, including methods for loading movie details, handling favorite/unfavorite states, and managing UI states like progress, error, and empty views. A corresponding mapper converts domain movie detail models into view models for the presentation layer.

_presentation/src/main/java/com/rodrigobresan/presentation/movie\details · high confidence

A new interface, MovieDataStore, is introduced to define the contract for movie data operations, including methods to save, retrieve, and delete movies and categories. A corresponding factory, MovieDataStoreFactory, is added to manage data retrieval by checking the connection status and cache state, returning either a remote or cached data store implementation.

_data/src/main/java/com/rodrigobresan/data/movie/sources/data\store · high confidence

Users can now view a detailed movie page that displays the movie's overview, tagline, rating, and title, along with a list of user reviews. The screen includes an interactive favorite button that toggles the movie's favorite status with a visual animation, and a tabbed interface for navigating between different sections of the movie's information.

_mobile/src/main/java/com/rodrigobresan/sampleboilerplateandroid/movie\detail · high confidence

A change to existing behaviour in keystores — 1 commit, 3 files.

keystores · medium confidence · unverified

A new data model class, MovieView, has been introduced to represent movie information in the presentation layer. This class encapsulates key movie details including the unique identifier, title, rating, poster path, and favorite status, providing a structured way to display movie data in the user interface.

presentation/src/main/java/com/rodrigobresan/presentation/movies/model · high confidence

Added instrumentation test infrastructure for the MoviesActivity; Added test coverage for CompletableUseCase; Added test data factories for movie, review, and category entities; Added test data factories for movies and reviews; Added unit tests for MovieDetailMapper; Added unit tests for MovieMapper; Added unit tests for MovieRemoteImpl and MovieRemoteMapper; Added unit tests for MovieServiceFactory; Added unit tests for movie data layer components; Added unit tests for movie detail data sources; Added unit tests for movie detail remote implementation and mapper; Added unit tests for movie domain use cases; Added unit tests for movie presentation layer; Added unit tests for remote review and movie data layers; Added unit tests for the GetMovieDetails use case; Added unit tests for the review data layer; Removed default Android test and boilerplate files.

The project has been refactored from a single \app\ module into a multi-module structure, introducing separate Gradle build files for \base\, \domain\, \data\, \cache\, \remote\, \presentation\, \mobile\, and \tv\ modules. A new \dependencies.gradle\ file centralizes all library versions and dependency declarations, which are then referenced by each module's \build.gradle\. The \settings.gradle\ file has been updated to include these new modules, and the root \build.gradle\ has been updated to apply the centralized dependencies and add plugins like JaCoCo and Fabric.

(dependencies) · high confidence

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

• CAI 49 → 31 (-17.5)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 100 → 98 (-1.6)
• Architecture 100 → 89 (-10.6)
• Maturity 55 → 55 (+0.0)
• Readiness 57 → 12 (-44.6)
• Security 57 → 43 (-14.7)
• Domain Modelling 33 → 36 (+2.2)

• 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
• Secret: generic-api-key (mobile/google-services.json)
• 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 licence statement (README.md)
• Documentation: no usage examples (README.md)
• Duplicated block (154 lines × 2) (mobile/src/main/java/com/rodrigobresan/sampleboilerplateandroid/injection/module/ApplicationModule.kt)
• Duplicated block (31 lines × 2) (base/src/main/java/com/rodrigobresan/base/DataFactory.kt)
• Duplicated block (7 lines × 2) (mobile/src/main/java/com/rodrigobresan/sampleboilerplateandroid/util/ConnectionUtils.kt)
• High secret: WD-SECRET-0004 (keystores/qakeystore)
• High secret: WD-SECRET-0004 (keystores/qakeystoretv)
• High secret: WD-SECRET-0004 (keystores/releasekeystore)
• Leaked secret: private-key-store (keystores/qakeystore)
• Leaked secret: private-key-store (keystores/qakeystoretv)
• Leaked secret: private-key-store (keystores/releasekeystore)
• No ADRs found
• No SBOM
• No build provenance
• No dependency advisory monitoring
• Secret: generic-api-key (fastlane/Fastfile)
• Secret: generic-api-key (fastlane/Fastfile)
• Secret: generic-api-key (remote/src/main/java/com/rodrigobresan/remote/service/MovieServiceParams.kt)
• …and 8 more

• Containers 0 added · 0 removed · contexts 6 added · 0 removed · edges 16 added · 0 removed

• cache
• data
• domain
• mobile
• presentation
• remote

• cache → data (coupling)
• cache → domain
• data → domain (coupling)
• mobile → cache
• mobile → data
• mobile → domain (coupling)
• mobile → presentation (coupling)
• mobile → remote
• presentation → data
• presentation → domain (coupling)
• remote → data (coupling)
• tv → cache
• tv → data
• tv → domain
• tv → presentation (coupling)
• tv → remote

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

rodrigobressan/android_tmdb_clean_architecture 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.