Skip to content
CAI
Software that uses CAICheck a score

atick-faisal/Jetpack-Android-Starter

74.6

Strong · 9 November 2026

16k

lines of production code

Kotlin

primary language

7

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Add Firebase Crashlytics integration for non-fatal error reporting

The analytics module now includes built-in crash reporting via Firebase Crashlytics. This change introduces a new \CrashReporter\ interface and a \FirebaseCrashReporter\ implementation, wired together through new Dagger/Hilt modules (\CrashlyticsModule\ and \FirebaseModule\). Users can now inject \CrashReporter\ into their ViewModels, repositories, or global exception handlers to log non-fatal exceptions, which are then asynchronously recorded and uploaded to Firebase for monitoring and debugging.

firebase/analytics/src/main/kotlin · high confidence

Add Firebase Firestore dependency injection modules

New Dagger Hilt modules have been added to the Firestore integration layer to wire up Firebase dependencies. FirebaseModule provides a singleton instance of FirebaseFirestore using the modern Firebase initialization API, while DataSourceModule binds the FirebaseDataSource interface to its implementation, enabling the application to inject and use Firestore for data operations.

firebase/firestore/src/main/kotlin/dev/atick/firebase/firestore/di · high confidence

Add Firebase Firestore module for remote data synchronization

A new \:firebase:firestore\ module has been introduced to serve as the remote sync target for the offline-first \home\ feature. This module provides \FirebaseDataSource\ implementations for reading, creating, and deleting jetpack records within a per-user Firestore collection. It utilizes a server-side timestamp (\serverUpdatedAt\) to order synchronization pulls, ensuring that the data layer correctly sequences updates based on the Firestore server clock rather than local device time. The module includes necessary ProGuard rules to preserve model classes during deserialization and excludes the Firebase SDK from the public API surface of the data layer.

firebase/firestore · high confidence

Add Profile screen with sign-out capability

The profile feature now includes a new ProfileScreen and ProfileViewModel, allowing users to view their profile picture and username and sign out of the application. The screen displays the user's avatar and name, provides a sign-out button, and handles loading states via a snackbar. The ViewModel fetches profile data from the repository and manages the sign-out flow.

feature/profile/src/main/kotlin/dev/atick/feature/profile · high confidence

Add item creation and editing screen

Users can now create and edit Jetpack library items via a new screen featuring a name field and a numeric price field. The price is kept as raw text during input to preserve partial entries, and is only parsed to a double upon saving. The screen supports both creating new items (with a generated UUID) and editing existing ones, loading data from the repository when an ID is provided.

feature/home/src/main/kotlin/dev/atick/feature/home/ui/item · high confidence

Add sign-in and sign-up navigation entry points

The authentication feature now exposes dedicated navigation destinations for signing in and signing up. A new \AuthNavigation\ file defines \SignInNavKey\ and \SignUpNavKey\ as serializable navigation keys and provides extension functions to navigate to these screens. The \authEntries\ function registers these destinations within a separate navigation graph that is displayed only while the user is signed out, ensuring that the back stack is swapped cleanly upon authentication state changes.

feature/auth/src/main/kotlin · high confidence

Add sign-in and sign-up screens with form validation

Users can now create a new account or log in to the app. The new sign-up screen collects a name, email, and password with real-time validation, supporting registration via email/password or Google Sign-In. The sign-in screen accepts an email and password, supporting login via email/password, Google Sign-In, or automatically signing in with previously saved credentials. Both screens include links to the Terms of Service and Privacy Policy.

feature/auth/src/main/kotlin/dev/atick/feature/auth · high confidence

Added Dagger Hilt module for SyncManager dependency injection

A new Dagger Hilt module (SyncModule) has been added to the sync module's dependency injection setup. This module binds the SyncManager interface to its implementation (SyncManagerImpl) as a singleton, enabling the application to inject the synchronization manager where needed.

sync/src/main/kotlin/dev/atick/sync/di · high confidence

Added NetworkPost data model for remote post retrieval

A new serializable data class, NetworkPost, has been introduced in the network module to represent posts fetched from a remote source. This model includes fields for the post's unique identifier, title, URL, and thumbnail URL, enabling the application to parse and handle network post data consistently.

network · high confidence

New Spotless configuration files have been added to define standard Apache 2.0 copyright headers for Kotlin (.kt, .kts) and XML (.xml) source files, ensuring consistent license text across the project.

spotless · high confidence

Added core testing module with shared test helpers

The \core/testing\ module has been added to provide shared JVM test helpers for repositories and ViewModels. This includes \MainDispatcherRule\ for replacing \Dispatchers.Main\ in tests, \FakeUserPreferencesDataSource\ for storing preferences in a \MutableStateFlow\, and \FakeAuthDataSource\ as an in-memory authentication data source that allows simulating sign-out errors and tracking calls. The module re-exports JUnit4, Kotlin test, coroutine test, Turbine, and Truth, and includes documentation on how to integrate these helpers into consuming modules.

core/testing · high confidence

Added startup baseline profile generation and cold-start benchmarks

The benchmarks module now includes a \BaselineProfileGenerator\ that captures the classes and methods executed during app startup (pressing Home, launching the activity, and waiting for idle) to create a release baseline profile for ahead-of-time ART compilation. Additionally, a \StartupBenchmark\ compares cold-start timings (\timeToInitialDisplayMs\) between a no-compilation baseline and the profile-applied mode, allowing users to quantify the performance improvement of the baseline profile. These benchmarks are designed to run on a Gradle Managed Device (pixel6Api33) and are not currently part of the automated CI workflows.

benchmarks · high confidence

A new set of scripts automates the assembly and verification of the project's documentation site. The \prepare\_docs\ script generates a build-ready documentation tree by combining authored Markdown with generated API pages, rewriting local links to be relative and pinning external repository links to the current commit. The \docs\_hooks\ script ensures that generated guide pages link back to their correct source files in the repository. Finally, the \check\_docs\ script validates the built site for broken local links and missing module introductions, ensuring documentation integrity before publication.

scripts · high confidence

Custom lint checks enforce design system wrappers and test naming conventions

The \:lint\ module now publishes two custom Android Lint checks to all modules depending on \core:ui\. The \DesignSystemDetector\ raises an ERROR when raw Material 3 composables (such as \Button\, \TextField\, or \TopAppBar\) are used directly instead of the project's \Jetpack\*\ wrappers, ensuring consistent theming and behavior; it resolves calls by package to avoid false positives from third-party libraries. The \TestMethodNameDetector\ issues a WARNING for test methods annotated with \@Test\ that start with the \test\ prefix, encouraging descriptive names that leverage the annotation's context.

lint · high confidence

Home screen displays Jetpack libraries with swipe-to-dismiss deletion

The Home screen now presents a list of Jetpack libraries in a staggered grid layout. Users can tap a library item to navigate to its details and can swipe a list item to dismiss (delete) it, which triggers an asynchronous update to the UI state. The view model manages this state by fetching the library list from the repository and handling deletion results, while the UI reflects sync requirements via a cloud icon on items that need synchronization.

feature/home/src/main/kotlin/dev/atick/feature/home/ui/home · high confidence

Initial fastlane configuration for Android release automation

Added fastlane setup for the Android application, including an Appfile targeting the package 'dev.atick.compose' and a Fastfile defining lanes for testing, Crashlytics beta distribution, and Google Play deployment. The deployment lane automatically generates changelogs from recent git commits and uploads the release bundle. Basic metadata files (title, short description, full description) and a README documenting the available actions were also added.

fastlane · high confidence

Introduce Firebase Auth module with email/password and Google Sign-In

The new firebase:auth module provides a unified authentication data source supporting email/password and Google Sign-In via Android's Credential Manager. It enables seamless one-tap sign-in by saving and retrieving credentials, handles user registration and session management, and abstracts Firebase-specific types into a domain AuthUser model. The module is wired into the app via Dagger Hilt modules for FirebaseAuth, CredentialManager, and the AuthDataSource implementation, and uses BuildConfig for the Google Web Client ID.

firebase/auth · high confidence

Introduce Firebase Firestore data source for offline-first sync

Added a new Firebase Firestore integration layer that enables bidirectional synchronization between the local Room database and the cloud. This change introduces the \FirebaseDataSource\ interface and its \FirebaseDataSourceImpl\ implementation, which handle pulling remote updates based on timestamps and pushing local changes (create, update, delete) to Firestore. The implementation follows an offline-first pattern where the local database remains the source of truth for the UI, while Firestore serves as the remote backup and sync hub, ensuring data consistency across devices.

firebase/firestore/src/main/kotlin/dev/atick/firebase/firestore/data · high confidence

Introduce FirebaseJetpack model with server-side timestamp support

Added the FirebaseJetpack data class to represent Jetpack items stored in Firestore, including fields for device-clock tracking (lastUpdated, lastSynced) and a server-assigned timestamp (serverUpdatedAt). This model enables sync operations to order pulls by the Firestore server clock, ensuring consistent data ordering across devices by leveraging server-side timestamps alongside local device clocks.

firestore · high confidence

Introduce Settings dialog with language, theme, and privacy controls

Users can now access a new Settings dialog to manage app preferences, including switching between English and Arabic, configuring dark mode and dynamic color themes, and signing out. The dialog also provides direct links to the Terms of Service, Privacy Policy, and Feedback channels, and adapts its layout width based on the current window size.

feature/settings/src/main/kotlin/dev/atick/feature/settings · high confidence

Introduce background data synchronization with WorkManager

The sync module now provides a complete background synchronization system using Android's WorkManager. The \Sync\ object initializes a unique, expedited work request on app startup to keep local data in sync with Firebase Firestore. A \SyncManager\ implementation exposes a reactive \isSyncing\ flow for UI indicators and allows on-demand sync triggers via \requestSync()\. The actual work is performed by \SyncWorker\, which runs as a foreground service to display progress notifications and handles bidirectional sync (pulling from and pushing to Firestore) with automatic retry logic (up to 3 attempts with exponential backoff). To support dependency injection in library modules, a \DelegatingWorker\ pattern is used to bridge WorkManager's reflection-based instantiation with Hilt.

sync/src/main/kotlin/dev/atick/sync/manager · high confidence

Introduce data module with offline-first architecture and Firebase sync

The new data module establishes the application's data layer, providing repository interfaces and implementations for authentication, home content, user profiles, and settings. It implements an offline-first architecture for Jetpack items using Room for local storage and Firebase Firestore for remote synchronization, managed by a background sync system. Authentication is handled via Firebase Auth (email/password and Google Sign-In), while user preferences and settings are persisted locally using DataStore. The module also includes a Hilt dependency injection module to bind repository interfaces to their implementations.

data/src/main · high confidence

Introduce local Room model for Jetpack items with sync metadata

Added a new Room entity, JetpackEntity, to store local data for Jetpack items, including fields for name, price, and user ID. The model incorporates specific metadata fields to support local-first synchronization, such as lastUpdated, lastSynced, serverUpdatedAtNanos, needsSync, deleted, and syncAction. This change establishes the local data structure required for tracking pending changes and syncing with the remote backend.

room · high confidence

Introduce offline-first Jetpack persistence with Room and sync tracking

The core/room module now provides a complete local data layer for Jetpack items using a Room database (JetpackDatabase) and a JetpackDao. This enables offline-first access to Jetpacks, scoped per user via the userId field, and supports reactive UI updates through Kotlin Flows. The implementation includes a LocalDataSource interface and its Hilt-bound implementation, which manages local CRUD operations and tracks synchronization state using sync metadata (needsSync, lastUpdated, lastSynced, deleted, and syncAction). Users benefit from soft-delete capabilities and automatic sync flags that allow a remote data source to reconcile local changes, while the database is configured with destructive migration for development safety.

core/room/src/main · high confidence

Introduces background sync via WorkManager with Hilt integration

The sync module now includes a \SyncWorker\ that performs push-then-pull synchronization using \HomeRepository\, reporting progress via a foreground notification and retrying up to three times on failure. To support Hilt dependency injection within WorkManager, a \DelegatingWorker\ proxy is added; it reads the target worker class name from input data and uses a Hilt entry point to instantiate the actual worker, allowing \SyncWorker\ to be created with injected dependencies like the I/O dispatcher and repository.

sync/src/main/kotlin/dev/atick/sync/worker · high confidence

Introduction of core/preferences module for type-safe user settings storage

A new core/preferences module has been added to provide type-safe local storage for user profile and application settings. The module utilizes a single JSON DataStore file, exposing data via Kotlin Flows for reads and suspend functions for writes. Key APIs include UserPreferencesDataSource for managing preferences such as username, profile picture URI, dark theme configuration, and dynamic color settings. The module includes a UserDataPreferences data class and a corresponding serializer, with specific handling for data corruption exceptions. Documentation highlights that all writes update the entire object, and a reset function is available to restore default values.

core/preferences · high confidence

Multi-tab navigation with per-tab back stacks and state restoration

The core/navigation module now implements a multi-back-stack navigation model using Jetpack Navigation 3. Users can switch between top-level tabs (e.g., Home, Profile) and each tab maintains its own independent back stack, preserving the user's position within that tab when switching away. The system back button intelligently navigates: it goes back within the current tab's stack if possible, or returns to the previously visited top-level tab if the current one is at its root. State is preserved across configuration changes and process death, ensuring that tab positions and nested navigation history are restored correctly. The Navigator API provides a unified entry point for navigation actions like navigate, goBack, and canGoBack, while decorators ensure ViewModel and saveable state are scoped per destination.

core/navigation · high confidence

New Activity and Lifecycle extension utilities

Added ActivityExtensions.kt and LifecycleExtensions.kt to the core UI module, providing helper functions for managing activity results, requesting runtime permissions with automatic settings navigation, observing LiveData with null filtering, handling one-time events, and collecting Kotlin Flows in a lifecycle-aware manner.

core/ui/src/main/kotlin/dev/atick/core/ui/extensions · high confidence

New Hilt modules for coroutine dispatchers, application scope, and string decoding

The dependency injection layer in the core Android module now includes three new Hilt modules to standardize background execution and utility bindings. DispatcherModule provides injectable, qualified coroutine dispatchers (IO, Default, Main) to improve testability and enforce correct thread usage for I/O versus CPU-bound tasks. CoroutineModule introduces an ApplicationScope annotation and provides a singleton CoroutineScope backed by a SupervisorJob and the Default dispatcher, enabling application-wide background operations that survive configuration changes without cancelling sibling coroutines on failure. StringDecoderModule binds the UriDecoder implementation as the StringDecoder interface, centralizing string decoding logic within the DI graph.

core/android/src/main/kotlin/dev/atick/core/di · high confidence

New Jetpack-branded Material 3 UI component library

The core UI module now includes a comprehensive set of new, reusable Jetpack-branded Compose components that wrap Material 3 primitives with consistent styling and enhanced features. This addition introduces \AppBackground\ and \AppGradientBackground\ for theme-aware surfaces, \JetpackButton\ variants (filled, outlined, text) with standardized icon/text slots, and \JetpackFilterChip\ with automatic checkmark icons. Navigation is supported by \JetpackNavigationBar\, \JetpackNavigationRail\, and a responsive \JetpackNavigationSuiteScaffold\ that adapts to window size. Additional components include \JetpackExtendedFab\, \JetpackIconToggleButton\, \DividerWithText\, \DynamicAsyncImage\ (with loading/error states and theme tinting), \JetpackLoadingWheel\ (with entry animations), and \SwipeToDismiss\ (with animated visual feedback). These components provide a unified visual language and reduce boilerplate for common UI patterns.

core/ui/src/main/kotlin/dev/atick/core/ui/components · high confidence

New core Android extension utilities

This change introduces a new set of Kotlin extension functions in the \core/android\ module to simplify common Android development tasks. \ContextExtensions\ provides helpers for retrieving the underlying Activity, showing Toasts, checking permissions, and creating/managing Notification Channels. \FlowExtensions\ adds a \stateInDelayed\ function to convert Flows to StateFlows with a 5-second stop timeout, optimizing performance during configuration changes. \NumberExtensions\ enables locale-aware number formatting (including currency) and Unix timestamp-to-date conversion. \StringExtensions\ adds validation for email addresses, passwords, and full names. Finally, \ThrowableExtensions\ offers utilities for formatting stack traces and wrapping errors in \OneTimeEvent\ for UI state management.

core/android/src/main/kotlin/dev/atick/core/extensions · high confidence

New core Android utility classes for coroutines, events, and decoding

This change introduces four new files to the core Android utilities module. CoroutineUtils adds suspend-safe error handling via suspendRunCatching (which preserves coroutine cancellation unlike runCatching) and timeout wrappers. OneTimeEvent provides a thread-safe wrapper for events that should be consumed only once, helping prevent duplicate UI actions like snackbars or navigation after configuration changes. StringDecoder defines an interface for decoding encoded strings, and UriDecoder provides an implementation using Android's Uri.decode method.

core/android/src/main/kotlin/dev/atick/core/utils · high confidence

New core UI utility components for state, localization, and previews

The \core/ui/utils\ package now includes several new utilities to standardize UI development. \StatefulComposable\ and \UiState\ provide a unified pattern for managing screen data, loading indicators, and error handling with automatic snackbar reporting. \LocaleUtils\ adds functions to get and set the application's preferred language, supporting the new language selection feature. \PreviewDevices\ and \PreviewThemes\ annotations simplify Compose preview testing across multiple device sizes and theme modes. Additionally, \SnackbarAction\ defines standard action types (NONE, REPORT, UNDO) for consistent snackbar behavior, \TakePictureActivityContract\ simplifies camera integration, \TextFieldData\ aids in form state management, and \UiText\ enables type-safe handling of localized and dynamic strings.

core/ui/src/main/kotlin/dev/atick/core/ui/utils · high confidence

New core/network module for REST data and connectivity monitoring

The app now includes a dedicated core/network module that provides a Retrofit-based REST client (JetpackRestApi) for fetching posts from a configurable backend URL, alongside a NetworkUtils component that emits a Flow of connectivity states (CONNECTED, LOST, UNAVAILABLE) based on Android's ConnectivityManager. This module also sets up the necessary Dagger Hilt bindings for the HTTP client, logging, and image loading (Coil with SVG support), and includes tests for the network state logic.

core/network · high confidence

New preference data models for user profile and settings

Added two new serializable data classes, PreferencesUserProfile and UserDataPreferences, to the preferences module. PreferencesUserProfile stores basic user identity details (ID, name, profile picture URI), while UserDataPreferences aggregates user settings including theme configuration (dark mode) and dynamic color preferences alongside the user profile data, enabling structured persistence and synchronization of user-specific UI and identity preferences.

preferences · high confidence

Profile feature navigation integration with Jetpack Navigation 3

The profile feature now uses Jetpack Navigation 3 for routing. A new navigation module defines a serializable destination key and registers the ProfileScreen as an entry, allowing the app to navigate to the profile tab and display the screen with snackbar support.

profile · high confidence

Project initialization with documentation, CI, and build configuration

The repository has been initialized with a comprehensive set of configuration and documentation files to support development and deployment. A Jenkins pipeline (Jenkinsfile) is provided to automate the generation of API documentation via Dokka and the deployment of MkDocs-based site documentation to GitHub Pages. Project standards are enforced through an EditorConfig file configured for ktlint/Spotless, and a new AGENTS.md file supplies AI coding agents with specific instructions, build commands, and architectural guidelines. The build system is configured with a Compose compiler stability configuration file, and default secrets for backend and Google authentication are established in secrets.defaults.properties. Additionally, the .gitignore has been updated to exclude generated build artifacts, AI tool local files, and sensitive configuration files like google-services.json.

(repo-wide) · high confidence

Sync progress notifications now display real-time update counts

The sync module now provides users with a foreground notification that shows the current progress of background synchronization tasks. This change introduces a Context extension that generates a progress notification, updating the displayed count of items processed versus the total, and ensures the notification channel is created automatically. Tapping the notification opens the main activity, giving users immediate visibility into sync status and a way to return to the app.

sync/src/main/kotlin/dev/atick/sync/extensions · high confidence

Architecture

Introduce Gradle convention plugins for standardized build configuration

The build system now uses a set of new convention plugins in the \build-logic/convention\ module to centralize and standardize configuration across the project. \ApplicationConventionPlugin\ and \LibraryConventionPlugin\ handle core Android setup, including the removal of the \kotlin-android\ plugin in favor of AGP 9.0+ built-in support, and the addition of the \kotlinx-serialization\ plugin. \UiLibraryConventionPlugin\ extends library configuration with Compose support. Additional plugins provide specialized setups: \DaggerHiltConventionPlugin\ configures Hilt with KSP and adds a workaround for a known Hilt error; \FirebaseConventionPlugin\ integrates Firebase Analytics, Crashlytics, and Performance; \DokkaConventionPlugin\ sets up documentation generation with custom plugins and a footer; and \TestConventionPlugin\ configures benchmark modules with Gradle Managed Devices. This refactoring simplifies module-level build scripts and ensures consistent build behavior.

build-logic/convention/src/main/kotlin · high confidence

Behavioural changes

App launch and navigation behavior overhaul

The app now initializes with a splash screen and manages its UI state through a new \App\ class and \MainActivityViewModel\, replacing the previous starter template. Navigation has been migrated to Jetpack Navigation 3, introducing separate back stacks for signed-in and signed-out states to prevent history leakage. The interface now supports edge-to-edge display, respects system dark mode and dynamic theming preferences, and displays a persistent snackbar when the device is offline.

app/src · high confidence

Automated code formatting and JVM toolchain configuration

The build system now enforces consistent code style and simplifies Java version management. An init script automatically applies Spotless (v8.9.0) with ktlint (v1.6.0) and Compose rules to Kotlin, Groovy, KTS, and XML files, ensuring standardized formatting and license headers across all subprojects. Additionally, a new gradle-daemon-jvm.properties file configures the Gradle toolchains resolver to automatically download and use JetBrains JDK 21 for all supported operating systems, removing the need for manual JDK installation.

gradle · high confidence

Centralized build-logic convention plugins for Android modules

The build-logic/convention module now provides a set of shared Gradle convention plugins that standardize configuration across all Android modules. These plugins automatically configure Compose (including the Compose BOM, opt-ins, and compiler metrics/reports), enforce consistent lint reporting (XML and SARIF for CI), and set up a unified test stack (JUnit 4, Turbine, Truth, Robolectric) with appropriate resource handling. Additionally, the build now includes APK badging checks to detect unintended manifest changes, registers Gradle managed virtual devices for consistent benchmarking and testing, and enforces resource prefixes to prevent naming collisions between library modules.

build-logic/convention/src/main/kotlin/dev · high confidence

Home feature adopts Jetpack Navigation 3 with adaptive list-detail layout

The home feature now uses Jetpack Navigation 3 to manage navigation between the home list and item detail screens. This change introduces an adaptive layout strategy: on wider screens, the list and detail panes render side-by-side, while on phones they behave as separate screens. The navigation logic is encapsulated in the new HomeNavigation.kt file, defining serializable keys for the home tab and item details, and registering the corresponding entries with the navigator.

home · high confidence

Introduce edge-to-edge theming and splash screen in MainActivity

The app now initializes a splash screen and configures edge-to-edge display with dynamic status and navigation bar styling that automatically adapts to the user's dark/light theme preference. Theme settings are derived from system state and user preferences (stored in UserDataPreferences), ensuring the UI respects dynamic color and dark mode choices from launch.

app/src/main/kotlin/dev/atick/compose · high confidence

Introduce user preferences storage via Jetpack DataStore

The app now persists user session data and UI settings using Jetpack DataStore instead of the previous storage mechanism. This change introduces a new \core/preferences\ module that manages user profile information (ID, name, avatar), theme preferences (dark mode, dynamic colors), and onboarding state. Users will experience reactive UI updates when changing settings like dark mode, and their authentication session and profile details are now stored in a type-safe, crash-safe manner that survives app restarts.

core/preferences/src/main · high confidence

Migrate UI theme to Material 3 Expressive with dynamic color support

The core UI theme has been updated to use Material 3 Expressive, introducing a new \JetpackTheme\ composable that applies expressive typography and supports dynamic color theming on Android 12+ devices. The theme now exposes background, gradient, and tint settings via CompositionLocal providers, allowing components to adapt to the active color scheme and elevation levels.

core/ui/src/main/kotlin/dev/atick/core/ui/theme · high confidence

Updated ProGuard rules for serialization and Crashlytics deobfuscation

The app's ProGuard configuration has been updated to ensure correct runtime behavior and debuggable crash reports. It now explicitly preserves \@Serializable\ classes from the Kotlinx Serialization library to prevent obfuscation issues with navigation destinations, and retains \SourceFile\ and \LineNumberTable\ attributes to enable Crashlytics to provide deobfuscated stack traces.

app · high confidence

Test coverage

Added core testing utilities for unit tests; Added reference tests for data repository implementations; Added tests for ItemViewModel price handling and error states; Added unit tests for JetpackDao; Added unit tests for SettingsViewModel; Added unit tests for UI components and state-management utilities; Added unit tests for core utilities and preferences.

Dependencies

Gradle wrapper upgraded to version 9.6.1

The Gradle wrapper has been updated from version 7.0.2 to 9.6.1, requiring a download of the new distribution. This upgrade also introduces new configuration properties for network timeout (10000ms), retry logic (0 retries with 500ms back-off), and distribution URL validation, which may affect build stability and startup behavior in environments with restricted network access or strict validation policies.

gradle/wrapper · high confidence

Initial project scaffolding with Gradle convention plugins and dependency catalog

The project is initialized with a multi-module Android architecture (app, core, data, feature, firebase, sync) and a build-logic convention plugin system to standardize configuration. Dependency management is centralized in gradle/libs.versions.toml, establishing versions for Android Gradle Plugin 9.3.1, Kotlin 2.4.10, Compose BOM 2026.06.01, and Firebase BOM 34.17.0. The build also includes a Ruby Gemfile for Fastlane 2.237.0 to support CI/CD automation.

(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 68 → 75 (+6.4)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.2) — scores are not directly comparable.

Lenses

  • Code Health 98 → 99 (+1.3)
  • Architecture 92 → 92 (+0.0)
  • Maturity 60 → 81 (+21.4)
  • Readiness 65 → 65 (-0.1)
  • Security 83 → 77 (-6.1)
  • Performance 79 → 94 (+14.8)

Resolved (3)

  • Documentation: no project overview (README.md)
  • check_docs.check (cognitive 47) (scripts/check_docs.py)
  • check_docs.check (cyclomatic 21) (scripts/check_docs.py)

New (1)

  • Outdated: fastlane

Changes since last survey

  • 11 commits — 10 feature/other, 1 fixes

By area

  • (root) — 5 commits
  • .github/workflows — 3 commits
  • app/dependencies — 1 commit
  • docs/build-and-tooling.md — 1 commit
  • docs/features — 1 commit

Notable commits

  • fix: 🐛 fix(ci): skip CI on the Dependency Guard bot commit (RENOVATE-BASELINES-01)
  • change: Update all dependencies
  • change: Update dependency ruby to v4.0.9
  • change: 👷 ci(jenkins): verify builds and archive results [no-task]
  • change: 📌 chore(deps): update Dependency Guard baseline [no-task] [skip ci]
  • change: 📝 docs(build): explain why the baseline bot commit has no checks (RENOVATE-BASELINES-01)
  • change: 📝 docs(firebase): document tracked rules and CLI deploy [no-task]
  • change: 📝 docs(plan): log approval-gated bot run pitfall (RENOVATE-BASELINES-01)
  • change: 🔒 chore(firebase): track transitional Firestore rules [no-task]
  • change: 🔖 chore(release): bump version to 2.0.0 and update changelog [no-task]
  • change: 🔧 chore(firebase): add firebase.json for CLI rules deploy [no-task]

Architecture

  • Containers 0 added · 0 removed · contexts 2 added · 2 removed · edges 3 added · 3 removed

Added bounded contexts (2)

  • feature/auth
  • firebase/auth

Removed bounded contexts (2)

  • feature/auth
  • firebase/auth

Added dependency edges (3)

  • feature/auth → data
  • data → firebase/auth
  • testing → firebase/auth (coupling)

Removed dependency edges (was a dependency, now gone) (3)

  • data → firebase/auth
  • feature/auth → data
  • testing → firebase/auth (coupling)

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

Survey your own repository

atick-faisal/Jetpack-Android-Starter 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 9f26790f33ebf0cc06851c4f7bedbc5164966c28 — 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.