nkuppan/expensemanager

This system is an Android expense management application that enables users to track income and expenses through detailed transaction logging, budget planning, and financial analysis. It provides core capabilities for managing accounts and categories with custom icons, visualizing spending via charts and widgets, and exporting data to CSV or PDF formats. The application supports multi-currency handling, localized settings, and secure access via an app lock, all built on a modular architecture using Jetpack Compose and Koin.

65 changes.

The project was restructured from a single module into a multi-module architecture with centralized dependency management using Koin and Jetpack Compose. Core features for expense tracking, including accounts, categories, budgets, and transactions, were implemented alongside a comprehensive design system and database schema upgrades. The period also focused on stabilizing app startup, adding performance benchmarks, and establishing unit test coverage for the new domain layer.

18 changes.

This period focused on migrating the application's dependency injection from Hilt to Koin and standardizing build configurations through centralized convention plugins. Concurrently, the codebase adopted a unidirectional data flow pattern with sealed-action state management across multiple feature modules, while introducing new user-facing capabilities such as country selection, home screen widgets, and language settings.

Users can now select their country and currency via a new bottom sheet interface. This feature includes a searchable list of countries with their associated currencies, powered by a new Koin-based ViewModel and Compose UI components within the country feature module.

feature/country/src/main/kotlin/com/naveenapps/expensemanager/feature/country · high confidence

Introduced four new domain-layer use cases to manage the application's initial setup state: GetOnboardingStatusUseCase and SetOnboardingStatusUseCase now allow the app to check and record whether the user has completed the onboarding flow, while GetPreloadStatusUseCase and SetPreloadStatusUseCase handle the status of data preloading. These components interact with the SettingsRepository to expose boolean flags for these states, enabling the UI layer to determine whether to show onboarding screens or preload data.

core/domain/src/main/kotlin/com/naveenapps/expensemanager/core/domain/usecase/settings/onboarding · high confidence

A new macrobenchmark module has been introduced to measure and optimize application startup performance. This includes tests that capture baseline profiles and compare startup timing metrics between unoptimized and baseline-profile-compiled builds, ensuring faster initial load times for users.

macrobenchmark · high confidence

A new extension function has been added to the data layer's utility package, allowing the application to read currency configuration files directly from the app's assets folder. This enables the system to load localized currency symbols and formatting rules dynamically at runtime.

core/data/src/main/kotlin/com/naveenapps/expensemanager/core/data/utils · high confidence

The app now centralizes number formatting configuration, allowing users to choose between displaying numbers with or without grouping separators (e.g., '1,234.56' vs '1234.56'). This setting is persisted via Android DataStore and applied globally to expense entries, ensuring that numbers are formatted according to the user's preference and the device's locale for both display and editing.

core/settings · high confidence

The core model module now defines the foundational data structures for the application, including Account, Category, Transaction, Budget, and Currency. This change introduces a dedicated Amount type to handle monetary values and currency symbols, replacing previous string-based placeholders. It also adds UI-specific models like AccountUiModel and TransactionUiItem to bridge domain data with the interface, and supports new capabilities such as custom account icons, budget period selection (monthly/yearly), and multi-currency handling.

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

Users are now presented with a new onboarding screen upon first launch to configure their primary currency and view existing accounts. This feature allows users to select a main currency via a country selection bottom sheet and provides a 'Proceed' button to complete the setup and navigate to the home screen. The flow checks the onboarding status to ensure it only appears for new users, integrating with the app's navigation and Koin dependency injection.

feature/onboarding/src/main/kotlin/com/naveenapps/expensemanager/feature/onboarding · high confidence

The application now exposes a comprehensive set of new repository interfaces in the core data layer, providing the foundation for several upcoming user-facing capabilities. These include \ImageStorageRepository\ for custom image selection on categories, accounts, and transactions; \SettingsRepository\ to support app lock and home summary compact views; \ShareRepository\ with updated methods for in-app reviews and sharing; and dedicated repositories for analytics, backups, budgets, and locale management.

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

The app now includes an About screen that displays the current app version and provides direct access to the About Us details, Terms and Conditions, Privacy Policy, and Open Source Licenses. It also includes buttons to contact the developer via GitHub, Twitter, Instagram, or email. This feature is implemented using Jetpack Compose and Koin for dependency injection.

feature/about/src/main/kotlin/com/naveenapps/expensemanager/feature/about · high confidence

The Analysis feature now provides a dedicated screen that displays a line chart of transaction data, an income/expense balance summary (available in both compact and detailed layouts), and a section showing average and projected values. The screen integrates a date filter, respects the current theme (including dark mode styling for charts and markers), and is wired up via a new Koin dependency injection module for the view model.

feature/analysis/src/main/kotlin/com/naveenapps/expensemanager/feature/analysis · high confidence

A new domain use case, ExportFileUseCase, has been introduced to handle the creation of export files. This component orchestrates the export process by fetching transactions via GetExportTransactionsUseCase and delegating file generation to ExportRepository, supporting both CSV and PDF formats based on the specified ExportFileType.

core/domain/src/main/kotlin/com/naveenapps/expensemanager/core/domain/usecase/settings/export · high confidence

A new Budget Detail Screen has been added, allowing users to view a specific budget's summary (including progress bar and percentage) and a list of associated transactions. The screen provides actions to edit the budget itself or add new transactions directly from the detail view, with navigation handled via Koin dependency injection and the app's Compose navigator.

feature/budget/src/main/kotlin/com/naveenapps/expensemanager/feature/budget/details · high confidence

The transaction feature now includes a dedicated number pad dialog that allows users to input amounts using a calculator-style interface. This new component supports basic arithmetic operations (addition, subtraction, multiplication, division) and mathematical functions (square root, sine, cosine, tangent), automatically evaluating expressions as the user types. The UI displays both the raw expression and the calculated result, with a large, bold display for the current value and a backspace button for easy correction. This replaces the previous standard keyboard input method for entering transaction values.

feature/transaction/src/main/kotlin/com/naveenapps/expensemanager/feature/transaction/numberpad · high confidence

Users can now view a dedicated details page for each category, which displays a summary of the category's total spending and a scrollable list of individual transactions associated with it. From this screen, users can open the category editor to modify settings, create new transactions within the category, or edit existing transactions directly from the list.

feature/category/src/main/kotlin/com/naveenapps/expensemanager/feature/category/details · high confidence

The category selection interface has been replaced with new screens that support both single and multiple category selection. Users can now select multiple categories simultaneously in the filter view, with visual indicators (checkmarks) and a count of selected items. The selection screen includes options to clear all selections or apply changes, and displays a toast message if no categories are selected when applying. The UI uses consistent card-based items with icons and background colors, and supports custom image paths for category icons.

feature/account/src/main/kotlin/com/naveenapps/expensemanager/feature/account/selection, feature/category/src/main/kotlin/com/naveenapps/expensemanager/feature/category/selection · high confidence

A new screen has been added to display transactions grouped by category, featuring a pie chart that visualizes expense versus income distribution. Users can switch between expense and income views, tap individual items to view category details, and use a floating action button to create new transactions. The screen also includes a filter view and an edit button to navigate to the category list.

feature/category/src/main/kotlin/com/naveenapps/expensemanager/feature/category/transaction · high confidence

This change introduces a suite of new utility classes and Kotlin extensions in the core common module to support application-wide functionality. Key additions include AppCoroutineDispatchers for structured concurrency, UiState for managing UI loading states, and various extension functions for Context (sharing, printing, email), DateUtils (date range calculations and timezone conversions using kotlinx.datetime), NumberUtils (compact number formatting), StringExt (capitalization and percentage formatting), and ColorExt (color string conversion and amount-based text color logic).

core/common/src/main/kotlin/com/naveenapps/expensemanager/core/common/utils · high confidence

The core design system now includes a suite of new UI components to enhance the user experience across the app. Users can now view a consolidated financial overview via the new AmountSummaryView, which displays income, expenses, and balance in a single card. List management has been improved with the addition of drag-and-drop reordering for items like accounts, and empty or loading states are now handled by dedicated EmptyItem and LoadingItem components. For visual customization, the system introduces IconAndColorComponent, which allows users to select icons and colors for categories and accounts through integrated ColorSelectionScreen and IconSelectionScreen interfaces. Additionally, transaction attachments can now be managed using AttachmentPickerScreen for selecting photos and AttachmentThumbnail for previewing and removing them, while DeleteDialogItem provides a consistent confirmation flow for deletions.

core/designsystem/src/main/kotlin/com/naveenapps/expensemanager/core/designsystem/components · high confidence

The design system module now includes a set of new utility components to support UI consistency and functionality. ImagePickerActions introduces a reusable Composable for handling camera and gallery image selection, including permission management, which enables custom image attachment for categories and accounts. ThemeUtils centralizes color definitions, providing functions to retrieve specific income, expense, and balance colors from the app's resources. CommonStyles defines standard Modifier specifications for icons and list items to ensure uniform spacing and sizing. Additionally, UiText provides a sealed class abstraction for handling both static string resources and dynamic server-side messages, ensuring consistent text rendering across the application.

core/designsystem/src/main/kotlin/com/naveenapps/expensemanager/core/designsystem/ui/utils · high confidence

The design system now includes three new utility components in the utils package to support common Compose patterns. BackHandler provides a composable wrapper for handling Android back navigation with lifecycle awareness. ComposeTheme introduces a shouldUseDarkTheme helper to determine dark mode state based on AppCompat delegate settings. LifeCycleAsEvents adds an ObserveAsEvents composable to safely collect lifecycle-aware flows using repeatOnLifecycle.

core/designsystem/src/main/kotlin/com/naveenapps/expensemanager/core/designsystem/utils · high confidence

The app now exposes dedicated domain use cases to handle currency settings, allowing users to retrieve the selected or default currency, format monetary amounts, and save new currency configurations with validation. These use cases (GetCurrencyUseCase, GetDefaultCurrencyUseCase, GetFormattedAmountUseCase, and SaveCurrencyUseCase) act as the domain-layer interface to the CurrencyRepository, ensuring that currency symbol and name are validated before being persisted.

core/domain/src/main/kotlin/com/naveenapps/expensemanager/core/domain/usecase/settings/currency, core/domain/src/main/kotlin/com/naveenapps/expensemanager/core/domain/usecase/settings/theme · high confidence

This change introduces a new set of domain-layer use cases that allow users to manage their filter preferences for accounts, categories, transaction types, and date ranges. The new module includes operations to get and update selected accounts, categories, and transaction types, as well as to retrieve, save, and navigate (forward/backward) through date ranges. These use cases are wired together via a new Koin module, enabling the UI to persist and modify user-defined filter configurations.

core/domain/src/main/kotlin/com/naveenapps/expensemanager/core/domain/usecase/settings/filter · high confidence

The application now exposes dedicated domain-layer use cases to handle reminder configuration. Users can retrieve the current reminder status and time settings, update the reminder's on/off state, and save new reminder time preferences. These changes provide a structured way to interact with the underlying reminder repository, ensuring that reminder settings are managed consistently across the app.

core/domain/src/main/kotlin/com/naveenapps/expensemanager/core/domain/usecase/settings/reminder · high confidence

Users can now view key financial data on their device home screen via a new Glance-based widget. This widget displays current income, expenses, and balance, along with the three most recent transactions, allowing for quick monitoring without opening the app.

app/src/main/kotlin/com/naveenapps/expensemanager/widget · high confidence

The core design system now includes a suite of new, reusable Compose components tailored for the expense manager app. These include AppCardView for styled card containers, AppDialog and SafeModalBottomSheet for standard and safe dismissal dialogs, and AppDatePickerDialog and AppTimePickerDialog for date and time selection. Input handling is improved with AppTextField and AutoSelectTextField, which automatically selects text on focus. The UI also gains ExpenseManagerTopAppBar for consistent navigation bars, IconAndBackgroundView and IconOrCustomImage for rendering category/account icons with optional user photos, and MonthPicker for date-range filtering. Data visualization is supported by PieChartView, while navigation and layout are aided by NavigationButton, SelectionTitle, SettingRow, SettingToggleRow, and SettingsSection for settings screens, and AppFilterChip for filtering options.

core/designsystem/src/main/kotlin/com/naveenapps/expensemanager/core/designsystem/ui/components · high confidence

Users can now select their preferred language via a new dialog interface. This change introduces the domain-layer use cases (ApplyLocale, GetCurrentLocale, GetLocales, SaveLocale) to manage locale settings and a new feature module containing the LanguageDialog UI, its ViewModel, and the Koin dependency injection module to wire them together.

core/domain/src/main/kotlin/com/naveenapps/expensemanager/core/domain/usecase/settings/locale, feature/language/src/main/kotlin/com/naveenapps/expensemanager/feature/language · high confidence

Users can now choose their preferred app theme (Light, Dark, Auto, or Follow System) via a new dialog interface. This change introduces the ThemeDialog UI component and its supporting ViewModel, which manages theme state and persistence. The implementation migrates the dependency injection for this feature from Hilt to Koin, as evidenced by the new Koin module and koinViewModel usage.

feature/theme/src/main/kotlin/com/naveenapps/expensemanager/feature/theme · high confidence

The design system module now includes two new Kotlin extension files: ContextExt.kt and UtilExt.kt. ContextExt.kt provides a getDrawable() extension that safely resolves drawable resources by name, falling back to a default account balance icon if the resource is not found. UtilExt.kt adds a toColor() extension for String, allowing hex color strings to be easily converted into Compose Color objects. These utilities simplify common UI resource handling within the app.

core/designsystem/src/main/kotlin/com/naveenapps/expensemanager/core/designsystem/ui/extensions · high confidence

A new account reordering screen has been added, allowing users to change the sequence of their accounts by dragging and dropping items in a list. The interface includes a hint banner explaining the gesture, a save button that appears after changes are made, and a close action to discard changes. When saved, the new order is persisted by updating the sequence index of each account.

feature/account/src/main/kotlin/com/naveenapps/expensemanager/feature/account/reorder · high confidence

The app's dependency injection framework has been switched from Hilt to Koin. This change introduces new Koin module definitions (KoinAppModule, KoinRepositoryModule, KoinActivityModule) in the data layer to wire up repositories, Firebase services, and database components, replacing the previous Hilt-based injection setup.

core/data/src/main/kotlin/com/naveenapps/expensemanager/core/data/repository · high confidence

This change introduces a new set of Gradle convention plugins in the build-logic/convention module to standardize Android project setup. It centralizes core configuration (SDK 36, minSdk 26, Java 17, Compose, and versioning) into reusable plugins like AndroidAppBasicConfigPlugin and AndroidLibraryBasicConfigPlugin. It also adds specialized plugins for specific dependencies and features, including AndroidKoinPlugin (migrating dependency injection to Koin), AndroidRoomPlugin (adding Room with KSP), and AndroidComposeConfigPlugin (enabling Jetpack Compose). Additionally, it configures JaCoCo code coverage and test options across modules.

build-logic/convention · high confidence

The Account List screen has been restructured to use a unidirectional data flow pattern, introducing explicit state and action classes to manage UI updates and user interactions. This change replaces the previous implementation with a model where the ViewModel exposes a single state flow and processes actions (such as creating, editing, or reordering accounts) through a centralized action handler, resulting in more predictable behavior and easier testing for the account management feature.

feature/account/src/main/kotlin/com/naveenapps/expensemanager/feature/account/list · high confidence

The Advanced Settings screen has been restructured to improve discoverability by removing common settings (Defaults, Backup & Restore, App Lock, and Compact Summary) which are now available in the main Settings screen. This location now exclusively handles rare, set-once items, specifically offering a Date Filter dialog and an Account Re-ordering option, implemented via a new action-based state model.

feature/settings/src/main/kotlin/com/naveenapps/expensemanager/feature/settings/advanced · high confidence

The app now initializes with a splash screen and checks onboarding status before showing the main interface. If the app lock is enabled, users must authenticate via biometrics or device credentials before accessing the app. Additionally, the app now checks for immediate updates via Google Play Core on startup, and race conditions related to activity result registration and update callbacks have been fixed to prevent crashes during configuration changes or locale switches.

app/src/main/kotlin/com/naveenapps/expensemanager · high confidence

The app now includes an App Lock screen that requires user authentication before accessing the main interface. The home screen has been restructured with a new bottom navigation bar (Home, Analysis, Transaction, Category) and a centralized navigation host that manages routing to various feature screens like budgets, categories, and settings. Additionally, the app now requests notification permissions upon launching the home screen to enable reminder functionality.

app/src/main/kotlin/com/naveenapps/expensemanager/ui · high confidence

The application's initialization process has been refactored to use the AndroidX Startup library, replacing the previous mechanism. This change introduces dedicated Initializer components: KoinInitializer sets up the Koin dependency injection framework and loads all application modules; WorkManagerInitializer configures the worker factory to integrate with Koin; PreloadDatabaseInitializer handles the insertion of default categories and accounts; and AppInitializer orchestrates the final startup steps, such as applying theme and locale settings and checking notifications. This ensures a more structured and reliable startup sequence where dependencies like Koin are guaranteed to be ready before other components initialize.

app/src/main/kotlin/com/naveenapps/expensemanager/initializer · high confidence

The budget create and edit workflow has been rebuilt using a modern StateFlow/Action pattern. The new \BudgetCreateScreen\ and \BudgetCreateViewModel\ manage UI state via \BudgetCreateState\ and handle user interactions through \BudgetCreateAction\ events, replacing the previous implementation. This change improves state management consistency and supports features like selecting multiple accounts and categories, choosing budget periods (monthly/yearly), and handling budget deletion, all wired through the Koin dependency injection module.

feature/budget/src/main/kotlin/com/naveenapps/expensemanager/feature/budget/create · high confidence

The category domain layer now enforces validation before adding, updating, or deleting categories, rejecting operations if the category ID is blank or the stored icon's background color is missing or invalid. These category use cases are now explicitly wired into the application using Koin dependency injection via the new CategoryUseCaseModule.

core/domain/src/main/kotlin/com/naveenapps/expensemanager/core/domain/usecase/category · high confidence

The app now persists user preferences and configuration state using a new set of DataStore modules in the core data layer. This change introduces dedicated storage classes for currency, date ranges, locale, theme, app lock, onboarding status, and various filter selections (accounts, categories, transaction types), ensuring that user choices are reliably saved and restored across sessions.

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

The Country use case now uses Koin for dependency injection instead of the previous Hilt setup. The GetCountriesUseCase is registered as a singleton in the new CountryUseCaseModule, ensuring that the country list retrieval logic is properly initialized and available to the rest of the application.

core/domain/src/main/kotlin/com/naveenapps/expensemanager/core/domain/usecase/country · high confidence

The Currency Customization screen has been rewritten to use a state-driven architecture with explicit actions. The UI now consumes a centralized \CurrencyState\ and dispatches \CurrencyAction\ events (such as selecting a currency, changing the number format, or adjusting the currency symbol position) to the \CurrencyViewModel\. This replaces the previous callback-based approach, ensuring that changes to currency settings, number formatting, and symbol positioning are handled through a single, predictable flow.

feature/currency/src/main/kotlin/com/naveenapps/expensemanager/feature/currency · high confidence

The database access layer has been refactored to introduce a generic BaseDao interface for common CRUD operations and reorganized specific DAOs (Account, Budget, Category, Transaction). A key behavioral change is in TransactionDao, where insert and update operations now automatically adjust the balances of the source and destination accounts to reflect income, expense, or transfer amounts, ensuring account balances stay in sync with transaction history. Additionally, the TransactionDao now uses @Transaction annotations on read queries to ensure atomic retrieval of complex relations (like attachments and linked accounts) and supports filtering transactions by accounts, categories, types, and date ranges.

core/database/src/main/kotlin/com/naveenapps/expensemanager/core/database/dao · high confidence

The database module now uses Koin for dependency injection instead of the previous framework. This change introduces a new Koin module that provides the Room database instance along with its DAOs (Category, Account, Transaction, and Budget) as singletons, ensuring the application continues to access local data storage through the new DI container.

core/database/src/main/kotlin/com/naveenapps/expensemanager/core/database/di · high confidence

The database entities have been updated to support new user-facing features: accounts and categories now store a \customImagePath\ for custom icons, transactions can have multiple attachments via a new \TransactionAttachmentEntity\ table, and budgets are linked to accounts and categories through new relation tables (\BudgetAccountEntity\, \BudgetCategoryEntity\). Additionally, the \BudgetEntity\ now includes a \periodType\ column to distinguish between monthly and yearly budgets, and the \TransactionRelation\ class has been updated to include the list of attachments.

core/database/src/main/kotlin/com/naveenapps/expensemanager/core/database/entity · high confidence

The core database module now defines the Room schema at version 8, introducing a series of migrations that add support for account reordering (a \sequence\ column on accounts), budget period types (allowing monthly or yearly budgets), localized default category keys, custom image paths for categories and accounts, and a new \transaction\_attachment\ table to store multiple receipt images per transaction. These changes enable users to customize account display order, attach multiple photos to transactions, and benefit from localized names for built-in categories, while maintaining backward compatibility for existing data through the defined migration steps.

core/database/src/main/kotlin/com/naveenapps/expensemanager/core/database · high confidence

The database layer now includes explicit Room type converters to persist enum types (AccountType, CategoryType, TransactionType) as integer ordinals and to handle date serialization. Specifically, the new DateConverter ensures that all timestamps are stored in UTC within the database, addressing the change to store UTC timestamps, while converting them to local dates for application use.

core/database/src/main/kotlin/com/naveenapps/expensemanager/core/database/utils · high confidence

The date filter feature has been restructured to replace callback-based navigation with a unidirectional data flow using explicit actions and events. The UI now drives behavior through a \DateFilterAction\ sealed class (handling save, date selection, and dismissal) and observes outcomes via a \DateFilterEvent\ channel, while the \DateFilterState\ centrally manages the selected range type, custom date inputs, and UI visibility flags. This change streamlines how the date filter screen communicates user intent and updates its interface.

feature/filter/src/main/kotlin/com/naveenapps/expensemanager/feature/filter/datefilter · high confidence

The export feature has been restructured to use a state and actions pattern, introducing explicit action and event classes to manage UI interactions and outcomes. This change adds support for exporting data as PDF files in addition to the existing CSV format, allowing users to choose their preferred file type. The screen now handles account selection and date filtering through a streamlined flow, and includes improved error handling with snackbar notifications for export failures or success, along with a direct option to share the generated file.

feature/export/src/main/kotlin/com/naveenapps/expensemanager/feature/export · high confidence

The filter screen now uses a new unidirectional data flow architecture where UI interactions trigger specific FilterAction events (such as moving date ranges, showing/hiding filters, or removing accounts, categories, and transaction types) which are processed by the FilterViewModel to update the FilterState. This replaces previous callback-based mechanisms with a streamlined action-processing model, ensuring that date navigation, filter visibility toggles, and selection changes are handled consistently through the new state and action definitions.

feature/filter/src/main/kotlin/com/naveenapps/expensemanager/feature/filter · high confidence

This change introduces the initial configuration files for the Android application, including the Google Services JSON file which registers the app with Firebase Analytics and Crashlytics under the package name com.naveenapps.expensemanager. It also adds a lint baseline to suppress known FullBackupContent warnings in the backup rules, and defines ProGuard/R8 rules to preserve Gson serialization logic, Kotlin serialization classes, and specific Android libraries like OSS Licenses and Play In-App Review, ensuring these components function correctly during the build process.

app · high confidence

The budget list feature has been refactored to use a new unidirectional event flow architecture. Users now interact with the budget list via explicit actions (OpenBudgetCreate, EditBudget, ClosePage) handled by the BudgetListViewModel, which manages state updates and navigation through the AppComposeNavigator. This replaces previous callback-based patterns, providing a more consistent and predictable user experience when creating, editing, or dismissing budget entries.

feature/budget/src/main/kotlin/com/naveenapps/expensemanager/feature/budget/list · high confidence

The filter type selection feature now uses a unidirectional data flow pattern, replacing previous callback mechanisms with explicit actions and events. Users interacting with the filter screen (to select accounts, categories, or transaction types) will experience a streamlined response model where selections are processed via the new \FilterTypeAction\ sealed class and completion is signaled through \FilterTypeEvent\. This change affects the internal wiring of the \FilterTypeSelectionViewModel\ and its Compose UI, ensuring that state updates and navigation triggers are handled consistently through the new action/event contract.

feature/filter/src/main/kotlin/com/naveenapps/expensemanager/feature/filter/type · high confidence

The app now uses a new navigation system built on Kotlinx Serialization and Koin for dependency injection. This change introduces a sealed class hierarchy defining all app screens (such as Home, Settings, and Budget details) as serializable routes, replacing the previous string-based navigation. It also provides a robust navigator implementation that handles navigation commands via Kotlin Flows, including support for passing results back through the back stack and preventing crashes from rapid navigation events.

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

Mapper logic for Account, Budget, Category, Country, and Transaction has been moved into the data module. This introduces a new Country mapper to support country and currency data, updates Account and Category mappers to handle custom icon paths via a StoredIcon model, and changes the Transaction mapper to use a dedicated Amount model instead of a raw string placeholder.

core/data/src/main/kotlin/com/naveenapps/expensemanager/core/data/mappers · high confidence

The app's dependency injection for ViewModels has been switched from Hilt to Koin. This change introduces a new \ViewModelModule\ that explicitly registers \MainViewModel\ and \HomeViewModel\ and aggregates all feature-specific ViewModel modules (such as Budget, Transaction, and Settings) into a single Koin module, replacing the previous Hilt-based registration mechanism.

app/src/main/kotlin/com/naveenapps/expensemanager/di · high confidence

The application's dependency injection framework has been switched from Hilt to Koin. This change replaces the previous Hilt-based modules with new Koin modules across the codebase, including specific registrations for coroutine dispatchers, domain use cases, and feature-specific ViewModels (such as Filter and Onboarding). For users, this is an internal architectural update that maintains existing functionality while altering the underlying dependency management mechanism.

(repo-wide) · high confidence

The budget domain layer now includes a complete set of use cases for managing budgets, including adding, updating, deleting, and retrieving budget details and transactions. These use cases handle validation (e.g., ensuring accounts and categories are specified) and combine data from repositories to provide formatted UI models with progress percentages. Additionally, the dependency injection for these use cases has been migrated from Hilt to Koin, as evidenced by the new \BudgetUseCaseModule\ and \SettingsUseCaseModule\ files.

core/domain/src/main/kotlin/com/naveenapps/expensemanager/core/domain/usecase/budget · high confidence

The category list screen has been replaced with a new implementation that organizes categories into tabs for Expense and Income. Users can now filter their categories by type using the tab row, create new categories via the floating action button, and edit existing categories by tapping on them. The screen uses a state-driven architecture with Koin for dependency injection and handles navigation back to the previous screen.

feature/category/src/main/kotlin/com/naveenapps/expensemanager/feature/category/list · high confidence

The account creation screen has been rebuilt using a state-driven architecture (State/Action/ViewModel) to improve consistency and maintainability. Users now benefit from a refined UI that includes a segmented button for selecting account types (Regular or Credit), custom image selection for account icons, and a delete workflow with confirmation dialogs. The screen also supports both creating new accounts and editing existing ones, with automatic loading of account details and proper handling of currency formatting and balance calculations.

feature/account/src/main/kotlin/com/naveenapps/expensemanager/feature/account/create · high confidence

The category creation and editing interface has been rebuilt using a new state-driven architecture, introducing a segmented button to explicitly select between Income and Expense types. Users can now pick custom images for categories via gallery or camera, with the UI handling image storage and cleanup. The screen also supports editing built-in default categories, preserving their localized names while allowing changes to icons and colors, and includes a dedicated delete workflow for user-created categories.

feature/category/src/main/kotlin/com/naveenapps/expensemanager/feature/category/create · high confidence

The dashboard screen has been updated to include a new CategoryAmountView that displays a pie chart of spending by category alongside the top four transactions, providing a clearer visual summary of expenses. The interface now uses a centralized DashboardAction sealed class to handle user interactions, such as opening settings, editing transactions, or viewing budgets and accounts, replacing previous callback patterns. Additionally, the dashboard now integrates a FilterView for date range selection and displays account balances in a horizontal scrollable list, with the ViewModel managing state for transactions, budgets, and accounts using Koin for dependency injection.

feature/dashboard/src/main/kotlin/com/naveenapps/expensemanager/feature/dashboard · high confidence

The onboarding intro screen has been updated to include a Lottie animation and new feature chips, while also resolving a bug where the privacy policy text failed to display correctly after switching app languages. The implementation now uses a placeholder string for the privacy policy link to ensure reliable localization across locale changes.

feature/onboarding/src/main/kotlin/com/naveenapps/expensemanager/feature/onboarding/into · high confidence

The transaction creation workflow has been rebuilt using a new Compose-based architecture. Users now select the transaction type (Income, Expense, or Transfer) via a segmented button row that dynamically adjusts colors and icons. The screen manages a consolidated state for accounts, categories, and attachments, and includes a dedicated number pad for amount entry. Additionally, the feature now supports in-app review requests and integrates with the Koin dependency injection system for view model instantiation.

feature/transaction/src/main/kotlin/com/naveenapps/expensemanager/feature/transaction/create · high confidence

The transaction list screen has been rebuilt to display transactions grouped by date, showing daily totals and headers. Users can now swipe horizontally on individual transaction items to reveal Edit and Delete actions, providing a quicker way to manage entries without opening the details screen. The list also includes a filter view at the top and supports navigation to create or edit transactions via a floating action button or item clicks.

feature/transaction/src/main/kotlin/com/naveenapps/expensemanager/feature/transaction/list · high confidence

The app now uses Android WorkManager to schedule and deliver daily reminder notifications, ensuring they trigger even after device reboots. A new BootAlarmReceiver restarts pending reminders on boot, while the NotificationScheduler handles permission checks, notification channels, and enqueues a unique WorkManager task to display the reminder at the configured time.

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

The Reminder feature has been rewritten to include a permission check for Android 13+ (POST\_NOTIFICATIONS), ensuring users are prompted for permission before reminders can trigger. The UI now uses a toggle to enable/disable reminders and a time picker to schedule them, with the ViewModel handling state via Koin dependency injection instead of the previous Hilt setup.

feature/reminder/src/main/java/com/naveenapps/expensemanager/feature/reminder · high confidence

The Settings screen has been restructured to improve usability by moving the 'Defaults' section (default account, expense category, income category, and compact summary toggle) and the 'Security' section (app lock) from the Advanced Settings screen to the main Settings screen. This change allows users to configure these frequently used options directly from the primary settings view without navigating to a sub-screen. The main settings screen now also includes direct access to theme, language, currency, notifications, export, backup/restore, and about us features.

feature/settings/src/main/kotlin/com/naveenapps/expensemanager/feature/settings · high confidence

The transaction use cases in the domain layer (including Add, Update, Delete, Find, GetAmountState, GetAverageData, GetChartData, GetExpenseAmount, GetExportTransactions, GetIncomeAmount, GetTransactionByName, GetTransactionGroupByCategory, and GetTransactionWithFilter) have been restructured to use Koin for dependency injection. This change replaces the previous dependency injection mechanism, wiring these use cases through a new TransactionUseCaseModule that resolves their repository and helper dependencies via Koin's singletons.

core/domain/src/main/kotlin/com/naveenapps/expensemanager/core/domain/usecase/account, core/domain/src/main/kotlin/com/naveenapps/expensemanager/core/domain/usecase/transaction · high confidence

Added Robolectric configuration for Android SDK 29; Added UI tests for the account list screen; Added core testing utilities and fake data fixtures; Added instrumentation tests for database migrations v3 through v8; Added unit tests for AccountListViewModel; Added unit tests for Category List ViewModel; Added unit tests for TransactionCreateViewModel; Added unit tests for account creation and selection view models; Added unit tests for budget domain use cases; Added unit tests for category selection and transaction list view models; Added unit tests for core data repository implementations; Added unit tests for currency and date range settings use cases.

The project now includes a Gradle wrapper configuration file that specifies the use of Gradle version 8.13. This ensures that all developers and build environments use a consistent version of the Gradle build tool, eliminating potential discrepancies caused by different locally installed versions.

gradle · high confidence

The application has been reorganized from a single-module structure into a multi-module architecture, introducing distinct \core\ modules (common, data, database, datastore, designsystem, domain, model, navigation, notification, repository, settings, testing) and \feature\ modules (about, account, analysis, budget, category, country, currency, dashboard, export, filter, language, onboarding, reminder, settings, theme, transaction). This separation is supported by a new \build-logic\ convention plugin system that standardizes configuration across modules. Additionally, a \gradle/libs.versions.toml\ version catalog has been introduced to centrally manage all library versions and plugins, including Kotlin 2.2.20, Android Gradle Plugin 8.13.0, and various AndroidX and Firebase dependencies.

(dependencies) · high confidence

The repository has been initialized with the core project structure, including a .gitignore file to exclude build artifacts and IDE settings, standard Gradle wrapper scripts for building the Android application, an Apache 2.0 LICENSE file, and a comprehensive README.md detailing the app's features, architecture, and setup instructions.

(repo-wide) · high confidence

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

• CAI 50 → 53 (+3.5)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 94 → 93 (-0.4)
• Architecture 100 → 92 (-7.6)
• Maturity 60 → 63 (+3.2)
• Readiness 50 → 46 (-4.0)
• Security 32 → 46 (+13.9)
• Domain Modelling 100 → 70 (-30.3)

• Change coupling: MoveDateRangeBackwardUseCase.kt ↔ MoveDateRangeForwardUseCase.kt (core/domain/src/main/kotlin/com/naveenapps/expensemanager/core/domain/usecase/settings/filter/daterange/MoveDateRangeBackwardUseCase.kt)
• Coverage not included — suite not readable by the collector
• Dependency hygiene not measured — dependency manifest found but not parsed for hygiene
• Duplicated block (10 lines × 2) (feature/analysis/src/main/kotlin/com/naveenapps/expensemanager/feature/analysis/AnalysisGraphScreen.kt)
• Duplicated block (11 lines × 2) (app/src/main/kotlin/com/naveenapps/expensemanager/widget/ExpenseWidget.kt)
• Duplicated block (11 lines × 2) (feature/account/src/main/kotlin/com/naveenapps/expensemanager/feature/account/reorder/AccountReOrderScreen.kt)
• Duplicated block (11 lines × 2) (feature/category/src/main/kotlin/com/naveenapps/expensemanager/feature/category/details/CategoryDetailScreen.kt)
• Duplicated block (11 lines × 2) (feature/currency/src/main/kotlin/com/naveenapps/expensemanager/feature/currency/CurrencyCustomiseScreen.kt)
• Duplicated block (11 lines × 2) (feature/reminder/src/main/java/com/naveenapps/expensemanager/feature/reminder/ReminderScreen.kt)
• Duplicated block (12 lines × 2) (core/domain/src/main/kotlin/com/naveenapps/expensemanager/core/domain/usecase/transaction/AddTransactionUseCase.kt)
• Duplicated block (12 lines × 2) (feature/account/src/main/kotlin/com/naveenapps/expensemanager/feature/account/list/AccountListScreen.kt)
• Duplicated block (13 lines × 2) (core/database/src/main/kotlin/com/naveenapps/expensemanager/core/database/dao/TransactionDao.kt)
• Duplicated block (13 lines × 2) (feature/account/src/main/kotlin/com/naveenapps/expensemanager/feature/account/selection/AccountItemDefaults.kt)
• Duplicated block (13 lines × 2) (feature/account/src/main/kotlin/com/naveenapps/expensemanager/feature/account/selection/MultipleAccountSelection.kt)
• Duplicated block (14 lines × 2) (app/src/main/kotlin/com/naveenapps/expensemanager/widget/ExpenseWidget.kt)
• Duplicated block (14 lines × 2) (app/src/main/kotlin/com/naveenapps/expensemanager/widget/ExpenseWidget.kt)
• Duplicated block (14 lines × 2) (core/database/src/main/kotlin/com/naveenapps/expensemanager/core/database/dao/BudgetDao.kt)
• Duplicated block (14 lines × 2) (feature/category/src/main/kotlin/com/naveenapps/expensemanager/feature/category/details/CategoryDetailScreen.kt)
• Duplicated block (15 lines × 2) (app/src/main/kotlin/com/naveenapps/expensemanager/widget/ExpenseWidget.kt)
• Duplicated block (15 lines × 2) (feature/category/src/main/kotlin/com/naveenapps/expensemanager/feature/category/create/CategoryTypeSelectionView.kt)
• …and 42 more

• Change coupling: AccountSelectionScreen.kt ↔ TransactionListScreen.kt (feature/account/src/main/kotlin/com/naveenapps/expensemanager/feature/account/selection/AccountSelectionScreen.kt)
• Change coupling: AnalysisScreenViewModel.kt ↔ CategoryTransactionListScreen.kt (feature/analysis/src/main/kotlin/com/naveenapps/expensemanager/feature/analysis/AnalysisScreenViewModel.kt)
• Change coupling: AnalysisScreenViewModel.kt ↔ DashboardScreen.kt (feature/analysis/src/main/kotlin/com/naveenapps/expensemanager/feature/analysis/AnalysisScreenViewModel.kt)
• Change coupling: CategoryAmountView.kt ↔ DashboardViewModel.kt (feature/dashboard/src/main/kotlin/com/naveenapps/expensemanager/feature/dashboard/CategoryAmountView.kt)
• Change coupling: CategoryTransactionListViewModel.kt ↔ CategoryAmountView.kt (feature/category/src/main/kotlin/com/naveenapps/expensemanager/feature/category/transaction/CategoryTransactionListViewModel.kt)
• Change coupling: CurrencyRepositoryImpl.kt ↔ CurrencyExt.kt (core/data/src/main/kotlin/com/naveenapps/expensemanager/core/data/repository/CurrencyRepositoryImpl.kt)
• Change coupling: CurrencyRepositoryImpl.kt ↔ TransactionCreateViewModel.kt (core/data/src/main/kotlin/com/naveenapps/expensemanager/core/data/repository/CurrencyRepositoryImpl.kt)
• Change coupling: DashboardScreen.kt ↔ TransactionListScreen.kt (feature/dashboard/src/main/kotlin/com/naveenapps/expensemanager/feature/dashboard/DashboardScreen.kt)
• Change coupling: DateUtils.kt ↔ GetChartDataUseCase.kt (core/common/src/main/kotlin/com/naveenapps/expensemanager/core/common/utils/DateUtils.kt)
• Change coupling: MultipleAccountSelection.kt ↔ BudgetCreateScreen.kt (feature/account/src/main/kotlin/com/naveenapps/expensemanager/feature/account/selection/MultipleAccountSelection.kt)
• Change coupling: SettingsDataStore.kt ↔ GetTransactionWithFilterUseCase.kt (core/datastore/src/main/kotlin/com/naveenapps/expensemanager/core/datastore/SettingsDataStore.kt)
• Change coupling: TextFieldWidgets.kt ↔ TransactionCreateScreen.kt (core/designsystem/src/main/kotlin/com/naveenapps/expensemanager/core/designsystem/ui/components/TextFieldWidgets.kt)
• Change-coupling hub: AmountSummaryView.kt → AnalysisScreenViewModel.kt, CategoryTransactionListScreen.kt, CategoryAmountView.kt, DashboardScreen.kt, DashboardViewModel.kt (core/designsystem/src/main/kotlin/com/naveenapps/expensemanager/core/designsystem/components/AmountSummaryView.kt)
• Change-coupling hub: CategorySelectionScreen.kt → AccountSelectionScreen.kt, CategoryListScreen.kt, TransactionListScreen.kt (feature/category/src/main/kotlin/com/naveenapps/expensemanager/feature/category/selection/CategorySelectionScreen.kt)
• Dependency hygiene PARTLY measured — Maven/Gradle declarations read, no dependency graph resolved
• Documentation: no usage examples (README.md)
• Duplicated block (10 lines × 2) (feature/account/src/main/kotlin/com/naveenapps/expensemanager/feature/account/selection/AccountItemDefaults.kt)
• Duplicated block (11 lines × 2) (core/domain/src/main/kotlin/com/naveenapps/expensemanager/core/domain/usecase/transaction/AddTransactionUseCase.kt)
• Duplicated block (11 lines × 2) (feature/account/src/main/kotlin/com/naveenapps/expensemanager/feature/account/list/AccountListScreen.kt)
• Duplicated block (11 lines × 2) (feature/onboarding/src/main/kotlin/com/naveenapps/expensemanager/feature/onboarding/OnboardingScreen.kt)
• …and 88 more

• 10 commits — 10 feature/other, 0 fixes

• core/database — 2 commits
• (root) — 1 commit
• app/src — 1 commit
• build-logic/convention — 1 commit
• core/data — 1 commit
• core/designsystem — 1 commit
• feature/budget — 1 commit
• feature/onboarding — 1 commit
• feature/transaction — 1 commit

• change: Adding new type for the budget creation
• change: Adding new type for the budget creation
• change: Adding the custom image selection for category and account
• change: Adding the custom image selection for category, account and transactions
• change: Fixing the CompositionLocalProvider crash issues
• change: Fixing the crash issue on route re-direction and TransactionDao.kt
• change: Fixing the issue of the privacy policy text after localization.
• change: Fixing the launch review dialog
• change: Fixing the launch review dialog
• change: Updating the version name

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

nkuppan/expensemanager 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.