arthur3486/android-mvvm
55.8
Adequate · 9 November 2026
11.1k
lines of production code
Kotlin
primary language
7
measurements over time
What this system is
This system is an Android application demonstrating a layered architecture (MVVM) for managing data from the Marvel API. It implements a modular codebase with separate layers for data, domain, and UI, utilizing Dagger 2 for dependency injection and RxJava for asynchronous operations. The application features specific capabilities for loading characters, comics, and events, including image loading and navigation support.
Features
Add Dagger2-based MVVM base classes for Activities and Fragments
Introduced new base classes for Activities and Fragments that integrate Dagger2 for dependency injection. The \mvvm-dagger\ module provides \MvvmActivity\ and \MvvmFragment\ that automatically inject the associated ViewModel via Dagger. The \mvvm-navigation-dagger\ module offers the same functionality but extends the AndroidX Navigation component support. Both modules include standard project scaffolding such as ProGuard rules, Android manifests, and unit/instrumented tests.
mvvm-dagger, mvvm-navigation-dagger · high confidence
Add character and comic data store implementations
The data module now includes a complete data access layer for characters and comics, each with cache, database, and server implementations. This introduces the \CharactersDataStore\ and \ComicsDataStore\ interfaces, their respective \\*DataStoreFactory\ classes, and the concrete \\*CacheDataStore\, \\*DatabaseDataStore\, and \\*ServerDataStore\ classes that handle in-memory caching, local database persistence, and remote API calls respectively.
data · high confidence
Add image loading library with Glide implementation
Introduced a new image loading library (\imageloading\) providing a generic \ImageLoader\ interface and utility extensions for caching, alongside a concrete \GlideImageLoader\ implementation (\imageloading-glide\) that uses the Glide library to load images into \ImageView\ components with configurable options such as animation, caching, and cropping.
imageloading, imageloading-glide · high confidence
Added Android commons module with Dagger2 dependency injection setup
Introduced a new Android library module named 'commons' that establishes the foundational dependency injection (DI) infrastructure for the application. This includes a Dagger2 component (CoreComponent) and a corresponding module (CommonsModule) that provides essential dependencies such as the Android Application Context and a SchedulerProvider for background threading. The module also includes standard Android test scaffolding (unit and instrumented tests) and configuration files (ProGuard rules, AndroidManifest).
commons · high confidence
Domain layer introduces structured dependency injection and repository implementations
The domain module now includes a complete dependency injection setup using Dagger, with a \DomainComponent\ that wires up \CharactersModule\, \ComicsModule\, and \EventsModule\. Each module provides data stores and repository implementations (e.g., \CharactersRepositoryImpl\) that handle caching, database, and server data sources. The change also adds base repository classes (\AbstractRepository\, \Repository\ interface) and mapping extensions for converting data models to domain models, enabling a consistent, layered approach to data access across characters, comics, and events.
domain · high confidence
Initial app structure and base MVVM architecture
The app module now includes a complete base architecture for the sample application, introducing a Model-View-ViewModel (MVVM) structure using Dagger 2 for dependency injection. This includes base classes for Activities and Fragments that integrate with the MVVM framework, along with a comprehensive set of adapters and view models for displaying characters, comics, and events. The application also sets up the core navigation routes and initializes the RxJava and Marvel API components.
app/src · high confidence
Initial project scaffolding and configuration
The repository was initialized with essential build and configuration files. This includes an .editorconfig for consistent code formatting, a .gitignore for build artifacts, a .travis.yml for CI/CD automation, and the gradlew/gradlew.bat scripts for Gradle wrapper execution. The README.md was also updated to provide comprehensive documentation for the Android MVVM library and its demo application.
(repo-wide) · high confidence
Introduce the Marvel API client library
Adds the complete Marvel API client implementation, including the main Api interface, endpoint interfaces and implementations for Characters, Comics, and Events, along with the associated service interfaces, response models, and utility classes for request signing and constants.
marvel-api · high confidence
Introduces MVVM navigation base classes for Android
Adds new base classes for Android X Navigation integration: MvvmActivity and MvvmFragment provide built-in support for navigation graph initialization, destination navigation with extras and options, and back-stack management. MvvmNavHostFragment handles new intent, extra, and back press events. Utility extensions allow checking the start destination and adding arguments to the navigation graph. An instrumented test and a unit test are also included.
mvvm-navigation · high confidence
New MVVM architecture with domain entities and UI adapters
The application now uses a Model-View-ViewModel (MVVM) architecture. This introduces domain entities (Character, Comics, Event, Creator, Image, Url) that implement Parcelable for state saving, alongside corresponding data-layer entities and database Room entities. The UI layer now utilizes ViewHolders for list items and ViewModels to manage data loading and state, providing a structured approach to displaying and interacting with characters, comics, and events.
mvvm · high confidence
Behavioural changes
Added Gradle wrapper configuration
The project now includes a Gradle wrapper configuration file (gradle-wrapper.properties) that specifies the use of Gradle version 6.1.1. This ensures consistent build environments across all users and CI systems by pinning the Gradle distribution URL and local storage paths.
gradle · high confidence
Centralized ViewModel creation for app fragments
The app's dependency injection has been refactored to use a consistent, centralized approach for creating ViewModels across the Characters, Comics, and Events modules. Each module now explicitly provides its associated ViewModels via Dagger modules, ensuring that the correct repositories and scheduler providers are injected into the ViewModels. This change standardizes how UI components are initialized, making the codebase more maintainable and consistent.
app/src/main/java/com/arthurivanets/sample/di/modules/fragments · high confidence
Dependencies
Updated Android and third-party library dependencies
The project's build configuration has been updated with new versions of key libraries. This includes updates to AndroidX components (such as AppCompat 1.1.0, Fragment 1.2.5, and Navigation 2.3.0), as well as third-party libraries like Dagger 2.28.1, RxJava 2.2.19, and Glide 4.11.0. The Gradle build tools have also been upgraded to version 4.0.1.
(dependencies) · high confidence
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
How this codebase got here
Score
- CAI 52 → 56 (+3.7)
- Rubric changed (rubric-2026.10.5 → rubric-2026.11.2) — scores are not directly comparable.
Lenses
- Code Health 99 → 99 (+0.0)
- Architecture 85 → 85 (+0.0)
- Maturity 50 → 73 (+23.3)
- Readiness 41 → 41 (+0.0)
- Security 98 → 98 (+0.0)
- Domain Modelling 53 → 53 (+0.0)
Resolved (5)
- Duplicate intent: Both methods appear to handle state restoration. Android standard is onRestoreInstanceState, but the custom onRestoreState suggests a parallel or redundant mechanism.
- Duplicate intent: Both methods appear to handle state saving in Fragment. Android standard is onSaveInstanceState, but the custom onSaveState suggests a parallel or redundant mechanism.
- Duplicate intent: Both methods appear to handle state saving. Android standard is onSaveInstanceState, but the custom onSaveState suggests a parallel or redundant mechanism.
- Inconsistent return type: Activity's onBackPressed returns Unit (void), while Fragment's and the marker interface's onBackPressed return Boolean. This inconsistency makes it difficult to create a unified handler for back press events across components.
- Redundant interface: AbstractViewModel implements lifecycle methods that are also defined in the ViewModelLifecycle marker interface. If AbstractViewModel is the base class, it should implement the interface, but the duplication of signatures in the public surface suggests confusion about whether users should interact with the class methods or the interface methods.
Architecture
- Unchanged — 0 containers · 4 contexts · 1 edges
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
Survey your own repository
arthur3486/android-mvvm 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.
About this page
- The score is its most recent published measurement, taken on 9 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
- Measured at commit 495600968cd055bcf98d93d7fe6ab46038e125e7 — the exact code this score is about.
- Scored under rubric-2026.11.2 — the same rubric and the same method as every other entry in this index.
- Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.3+preprod-bb0cb800cd0f.