atick-faisal/Jetpack-Android-Starter

This is an offline-first Android application for managing 'Jetpack' items, featuring a multi-module architecture built with Jetpack Compose and Material 3. It handles user authentication via Firebase and synchronizes local Room database data with Firebase Firestore using a background WorkManager sync system. The app provides core features including item creation, editing, deletion, and profile management, supported by a robust build system with automated testing and CI/CD pipelines.

12 changes.

This period focused on initializing the multi-module Android project with a standardized Gradle build system, convention plugins, and dependency catalogs. It established the core architectural foundations, including Hilt dependency injection, Jetpack Compose UI components, and shared Android utilities, while configuring CI/CD pipelines and code quality tools.

21 changes.

This period focused on establishing a robust offline-first architecture by introducing dedicated core modules for network, preferences, and Room persistence, alongside a data layer that synchronizes local data with Firebase Firestore. Concurrently, the team implemented key user-facing features, including authentication flows, a refactored home screen with Jetpack Navigation 3, and profile and settings interfaces, while integrating Firebase services for analytics and crash reporting.

7 changes.

This period focused on establishing a robust development infrastructure by centralizing Gradle build conventions, introducing custom lint rules for design consistency, and implementing startup performance benchmarks. Concurrently, the team expanded test coverage by creating a dedicated testing module with fake data sources and adding comprehensive unit and reference tests for core utilities, Room DAOs, and settings features.

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

The authentication feature now includes dedicated navigation entries for the sign-in and sign-up screens. Users can navigate between these two screens, and the app manages the signed-out flow by swapping navigation graphs when the authentication state changes, ensuring no stale back stack remains after signing in or out.

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

The authentication feature now includes dedicated sign-in and sign-up screens. Users can sign in using saved credentials, Google Sign-In, or email and password, with real-time validation for email and password fields. The sign-up screen allows new users to register via Google or email/password, validating name, email, and password inputs. Both screens support vertical scrolling and include links to terms of service and privacy policy.

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

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

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

The benchmarks module now includes a BaselineProfileGenerator to create an ahead-of-time compilation profile for the app's startup flow, and a StartupBenchmark to measure cold-start times with and without that profile. This allows developers to quantify the impact of the baseline profile on initial load performance.

benchmarks · high confidence

This change introduces custom lint rules to the project. The DesignSystemDetector flags direct usage of Compose Material 3 composables (such as Button, Tab, or TextField) in favor of the project's wrapper components in :core:ui, ensuring consistent theming and behavior; it specifically resolves calls by their actual package to avoid false positives from third-party libraries with similar names. Additionally, the TestMethodNameDetector warns against test methods prefixed with 'test', encouraging names that describe behavior instead, and provides a quick-fix to remove the prefix.

lint · high confidence

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

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

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

A new firebase:firestore module has been added to the project, providing cloud data storage with real-time updates and offline persistence. The module introduces the FirebaseJetpack data model, which includes sync metadata fields (lastUpdated, lastSynced, deleted) to support an offline-first bidirectional synchronization pattern between a local Room database and remote Firestore. It also includes configuration for ProGuard rules to preserve model classes used for deserialization.

firebase/firestore · high confidence

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

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

The application now includes a dedicated \core/network\ module that centralizes HTTP communication using Retrofit and OkHttp, providing standardized patterns for REST API calls, network error handling, and connectivity monitoring. This module introduces a \NetworkDataSource\ interface to separate network logic from repositories, utilizes Kotlin serialization for JSON parsing, and includes \NetworkUtils\ for observing network state via Flow. To support this new structure, ProGuard consumer rules have been added to preserve necessary annotations, generic signatures, and model classes required by Retrofit and OkHttp during obfuscation.

core/network · high confidence

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

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

The application now includes a new \core/preferences\ module that provides type-safe, reactive local storage for user settings and app configuration using Jetpack DataStore. This module enables persistent management of lightweight key-value data such as theme preferences, language settings, and authentication tokens, replacing previous approaches with a model that offers reactive updates via Kotlin Flows and transactional safety without runtime exceptions.

core/preferences · high confidence

The firebase/analytics module now provides crash reporting capabilities via Firebase Crashlytics, despite its name. It introduces a CrashReporter interface and a FirebaseCrashReporter implementation to track non-fatal exceptions, along with Hilt dependency injection modules (CrashlyticsModule and FirebaseModule) to wire these components. This allows the application to automatically report uncaught exceptions and manually log errors for debugging and monitoring purposes.

firebase/analytics · high confidence

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

Users can now view their profile information, including their name and profile picture, in a vertically scrollable screen. The interface includes a prominent sign-out button that triggers the logout process via the new ProfileViewModel, which handles fetching profile data and managing UI state.

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

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

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

The app now includes a dedicated core network module that provides a complete stack for remote data access and connectivity awareness. It introduces a \NetworkDataSource\ interface and implementation to fetch \NetworkPost\ objects via a Retrofit-based REST API, utilizing OkHttp with configurable timeouts and logging. Additionally, it adds a \NetworkUtils\ service that monitors real-time network connectivity states (Connected, Losing, Lost, Unavailable) using Android's ConnectivityManager, allowing the application to react to network changes. The module is fully integrated with the app's dependency injection via Hilt modules for Retrofit, OkHttp, Coil (with SVG support), and network utilities.

core/network/src/main/kotlin · high confidence

The application now includes a dedicated \core:ui\ module that centralizes the user interface layer. This module provides a comprehensive set of reusable Jetpack Compose components styled with Material 3, including buttons, chips, navigation bars, and loading indicators. It also introduces a standardized state management pattern using \UiState\ and \StatefulComposable\ to handle loading, data, and error states consistently across screens, along with utilities for type-safe text handling and theme-aware backgrounds.

core/ui · high confidence

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

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

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

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

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

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

The Home feature has been refactored to use Jetpack Navigation 3, introducing a list-detail navigation pattern where the Home screen (a staggered grid of Jetpack items) and the Item screen (create/edit form) are registered as distinct destinations. The Home screen now supports swipe-to-dismiss to delete items, and the Item screen handles both creating new Jetpacks and editing existing ones, with navigation arguments passed via Navigation 3 keys rather than SavedStateHandle.

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

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

The core navigation module now implements a new \NavigationState\ and \Navigator\ architecture that maintains a separate back stack for each top-level tab. This ensures that switching tabs preserves the user's position within each tab, and pressing back from the root of a non-start tab returns to the previously visited tab rather than exiting the app. The implementation uses \rememberNavBackStack\ with \key()\ to ensure state restoration correctly maps back stacks to their specific destinations, preventing stack corruption after process death.

core/navigation · high confidence

The Profile feature has migrated its navigation implementation to Jetpack Navigation 3. This change introduces a new navigation entry point using the updated \EntryProviderScope\ and \NavKey\ APIs, replacing previous navigation patterns with the new library's structure for handling the profile screen.

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

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

Added reference tests for Room DAO, Settings Repository, and Settings ViewModel; Added test harness module with fake data sources and coroutine rules; Added unit tests for core utilities and preferences.

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

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 watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 54 → 79 (+24.9)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 100 → 99 (-0.6)
• Architecture 88 → 87 (-0.8)
• Maturity 73 → 76 (+3.3)
• Readiness 37 → 78 (+40.7)
• Security 56 → 79 (+22.6)

• Boundary-crossing change coupling: JetpackApp.kt ↔ ProfileNavigation.kt (app/src/main/kotlin/dev/atick/compose/ui/JetpackApp.kt)
• Boundary-crossing change coupling: JetpackAppState.kt ↔ AuthNavigation.kt (app/src/main/kotlin/dev/atick/compose/ui/JetpackAppState.kt)
• Boundary-crossing change coupling: NavHost.kt ↔ AuthNavigation.kt (app/src/main/kotlin/dev/atick/compose/navigation/NavHost.kt)
• Boundary-crossing change coupling: NavHost.kt ↔ ProfileNavigation.kt (app/src/main/kotlin/dev/atick/compose/navigation/NavHost.kt)
• Change coupling clique: MainActivity.kt, Color.kt, Theme.kt (app/src/main/kotlin/dev/atick/compose/MainActivity.kt)
• Change coupling: AuthNavigation.kt ↔ SignInScreen.kt (feature/auth/src/main/kotlin/dev/atick/feature/auth/navigation/AuthNavigation.kt)
• Dependency hygiene not measured — dependency manifest found but not parsed for hygiene
• Duplicated block (12 lines × 2) (feature/auth/src/main/kotlin/dev/atick/feature/auth/ui/signin/SignInScreen.kt)
• Duplicated block (13 lines × 2) (app/src/main/kotlin/dev/atick/compose/ui/JetpackApp.kt)
• Duplicated block (14 lines × 2) (feature/auth/src/main/kotlin/dev/atick/feature/auth/ui/signin/SignInScreen.kt)
• Duplicated block (5 lines × 3) (build-logic/convention/src/main/kotlin/ApplicationConventionPlugin.kt)
• Duplicated block (8 lines × 2) (build-logic/convention/src/main/kotlin/LibraryConventionPlugin.kt)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• …and 27 more

• Documentation: no architecture or design documentation (docs/state-management.md)
• Duplicated block (30–31 lines × 2) (feature/auth/src/main/kotlin/dev/atick/feature/auth/ui/signin/SignInScreen.kt)
• Duplicated block (43 lines × 2) (feature/auth/src/main/kotlin/dev/atick/feature/auth/ui/signin/SignInScreen.kt)
• FixmeComment (build-logic/convention/src/main/kotlin/DokkaConventionPlugin.kt)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• …and 34 more

• 20 commits — 18 feature/other, 2 fixes

• build-logic/convention — 5 commits
• .github/workflows — 3 commits
• lint/src — 2 commits
• .run/Check APK Badging.run.xml — 1 commit
• app/dependencies — 1 commit
• app/src — 1 commit
• core/android — 1 commit
• core/navigation — 1 commit
• core/network — 1 commit
• core/testing — 1 commit
• core/ui — 1 commit
• feature/auth — 1 commit
• gradle/libs.versions.toml — 1 commit

• fix: fix(lint): match design system calls by resolved package, not by name
• fix: fix(navigation): harden back handling and per-tab state restoration
• change: Bump gradle/actions from 6 to 6.2.0
• change: Update dependency com.google.devtools.ksp to v2.3.11
• change: Update gradle/actions action to v6.3.0
• change: build(lint): add custom lint checks for the design system
• change: build(run): add run configurations for verification, baseline and test tasks
• change: build: add dependency guard and APK badging checks
• change: build: drop the nonexistent :lint:lint task and two latent build-logic traps
• change: chore(res): delete unused strings and de-stutter the network keys
• change: chore: housekeeping ahead of upstream NIA sync
• change: chore: re-baseline dependencies and badging after merging main
• change: ci: run tests, dependency guard, lint and badging on every PR
• change: feat(navigation): migrate to Jetpack Navigation 3
• change: perf: add baseline profile generation and startup benchmarks
• change: refactor(build-logic): extract shared convention helpers
• change: test(core): add unit tests for the durable core utilities
• change: test(navigation): cover rememberNavigationState's save and restore path
• change: test: add reference tests for the repository, ViewModel and DAO patterns
• change: test: add test harness and :core:testing module

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

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.