MadMoney Mobile

Project Overview

MadMoney Mobile is a Kotlin/XML Android personal finance tracking app prototype. The app is designed to help users record income and expenses, organize transactions by category and account, view spending patterns, and review summary reports. The visual style is inspired by simple money-management apps such as Monefy: large balance numbers, quick-add actions, icon-based categories, chart summaries, and a bottom navigation flow.

This submission focuses on the Phase 2 UI prototype requirements: complete screens, consistent UI/UX design, working navigation, responsive layouts, organized resources, and a project structure that can become the foundation for the final app. The app includes local SQLite storage and seed data so the dashboard, transaction list, and reports show realistic information immediately after launch.

App Purpose

MadMoney Mobile solves a common budgeting problem: users often need a fast way to see where money is going without opening a complicated spreadsheet or bank app. The prototype supports a simple personal finance workflow:

Open the dashboard to see current balance, income, expenses, and recent activity.
Add an income or expense transaction using category and account selectors.
Browse, search, filter, edit, or delete transactions.
Review charts and reports to understand spending patterns.
Manage categories and accounts from the More screen.

Prototype Scope

This version is a functional UI prototype with local database support. It includes navigation, screens, form controls, lists, charts, seeded demo transactions, and basic CRUD behavior for prototype testing.

Included in This Prototype

Kotlin Android project using XML layouts
MVC-inspired package organization
Bottom navigation with Dashboard, Transactions, Add, Report, and More sections
Navigation graph with fragments and screen transitions
SQLite database helper with schema creation and seed data
Dashboard summary cards and category chart
Transactions list with search, filter, sort, edit, and delete features
Add Expense and Add Income forms
Edit Transaction form
Reports screen with category and trend charts
More screen for category/account management and data reset options
Resource-based strings, colors, themes, dimensions, layouts, menus, and navigation XML
Responsive dimension resources for wider screens/tablets

Not Included / Future Final-App Work

Cloud sync or online account login
Real bank API integration
User authentication
Push notifications
Export to CSV/PDF
Production-level security or encryption
Advanced analytics beyond the prototype charts

How to Open and Run the Project

Open Android Studio.
Select Open.
Choose the MadMoney project folder.
Wait for Gradle sync to complete.
Run the app on an Android emulator or physical Android device.

Recommended Environment

Item	Value
Language	Kotlin
UI System	XML layouts
IDE	Android Studio
Compile SDK	35
Target SDK	35
Minimum SDK	23
Java/Kotlin JVM Target	17
Application ID	`com.example.madmoney`
Version	`1.0`

Major Dependencies

The app uses standard Android and AndroidX libraries appropriate for a UI-focused Android project.

Dependency	Purpose
`com.google.android.material:material:1.12.0`	Material UI components such as BottomNavigationView and dialogs
`androidx.appcompat:appcompat:1.7.0`	AppCompat activity support
`androidx.constraintlayout:constraintlayout:2.2.0`	Responsive XML layouts
`androidx.fragment:fragment-ktx:1.8.5`	Fragment-based screen structure
`androidx.recyclerview:recyclerview:1.3.2`	Transaction list display
`androidx.core:core-ktx:1.15.0`	Kotlin Android extensions and utilities
`androidx.navigation:navigation-ui-ktx:2.8.5`	Navigation UI integration
`androidx.navigation:navigation-fragment-ktx:2.8.5`	Fragment navigation graph support

MVC Architecture

The project follows an MVC-inspired architecture. Android apps often blend responsibilities because fragments handle both screen logic and view binding, but this project intentionally separates model classes, controller fragments, XML views, adapters, chart views, and utilities.

MVC Role Breakdown

MVC Layer	Project Location	Responsibility
Model	`app/src/main/java/com/example/madmoney/model/`	Data objects and database operations
View	`app/src/main/res/layout/` and `app/src/main/java/com/example/madmoney/view/`	XML layouts and custom chart drawing classes
Controller	`app/src/main/java/com/example/madmoney/controller/`	Screen logic, navigation actions, form handling, list updates, and database calls
Adapter	`app/src/main/java/com/example/madmoney/adapter/`	Connects transaction data to RecyclerView rows
Utilities	`app/src/main/java/com/example/madmoney/util/`	Formatting, date filtering, money formatting, icon lookup, reusable helpers

Model Layer

The model layer contains the data classes and SQLite helper.

File	Purpose
`Transaction.kt`	Data class representing one income or expense transaction
`Category.kt`	Data class representing an income or expense category
`Account.kt`	Data class representing a cash, bank, wallet, or credit account
`MadMoneyDatabaseHelper.kt`	Creates the SQLite database, creates tables, inserts seed data, and provides database query/update methods

View Layer

The view layer is made of XML screen files and custom chart views.

File	Purpose
`activity_main.xml`	Root layout containing the NavHost and bottom navigation
`fragment_dashboard.xml`	Dashboard screen layout
`fragment_transactions.xml`	Transaction search/list/filter screen layout
`fragment_add_expense.xml`	Add Expense form layout
`fragment_add_income.xml`	Add Income form layout
`fragment_edit_transaction.xml`	Edit existing transaction form layout
`fragment_report.xml`	Reports and chart screen layout
`fragment_more.xml`	Settings, categories, accounts, and reset options layout
`row_transaction.xml`	Reusable transaction row layout for RecyclerView
`CategoryPieChartView.kt`	Custom donut/pie chart style view for category breakdowns
`HorizontalBarChartView.kt`	Custom horizontal bar chart view for reports
`LineChartView.kt`	Custom trend line chart view for report trends

Controller Layer

The controller layer contains MainActivity and the fragments. These classes react to user input, call model/database functions, and update the views.

File	Purpose
`MainActivity.kt`	Hosts the NavHostFragment, manages bottom navigation, and opens the Add dialog
`DashboardFragment.kt`	Loads dashboard summaries, recent transactions, period controls, and chart data
`TransactionsFragment.kt`	Shows transactions, search, sorting, filtering, edit, and delete interactions
`AddExpenseFragment.kt`	Handles expense form input and inserts expense transactions
`AddIncomeFragment.kt`	Handles income form input and inserts income transactions
`EditTransactionFragment.kt`	Loads an existing transaction and updates or deletes it
`ReportFragment.kt`	Loads report summary data and chart datasets
`MoreFragment.kt`	Handles category/account management and reset actions

Adapter Layer

File	Purpose
`TransactionAdapter.kt`	Binds transaction records to the RecyclerView row layout and handles row actions

Utility Layer

File	Purpose
`DateUtils.kt`	Date formatting and parsing helpers
`DateFilterUtils.kt`	Shared period/date-range filtering logic
`MoneyUtils.kt`	Currency and amount formatting helpers
`IconCatalog.kt`	Central icon catalog used by categories, accounts, lists, charts, and spinners

Project File Structure

MadMoney/
├── README.md
├── build.gradle.kts
├── settings.gradle.kts
├── gradle.properties
├── gradlew
├── gradlew.bat
├── gradle/
│   └── wrapper/
│       ├── gradle-wrapper.jar
│       └── gradle-wrapper.properties
└── app/
    ├── build.gradle.kts
    ├── proguard-rules.pro
    └── src/
        └── main/
            ├── AndroidManifest.xml
            ├── java/
            │   └── com/example/madmoney/
            │       ├── adapter/
            │       │   └── TransactionAdapter.kt
            │       ├── controller/
            │       │   ├── MainActivity.kt
            │       │   ├── DashboardFragment.kt
            │       │   ├── TransactionsFragment.kt
            │       │   ├── AddExpenseFragment.kt
            │       │   ├── AddIncomeFragment.kt
            │       │   ├── EditTransactionFragment.kt
            │       │   ├── ReportFragment.kt
            │       │   └── MoreFragment.kt
            │       ├── model/
            │       │   ├── Transaction.kt
            │       │   ├── Category.kt
            │       │   ├── Account.kt
            │       │   └── MadMoneyDatabaseHelper.kt
            │       ├── util/
            │       │   ├── DateUtils.kt
            │       │   ├── DateFilterUtils.kt
            │       │   ├── MoneyUtils.kt
            │       │   └── IconCatalog.kt
            │       └── view/
            │           ├── CategoryPieChartView.kt
            │           ├── HorizontalBarChartView.kt
            │           └── LineChartView.kt
            └── res/
                ├── drawable/
                │   └── ic_launcher.xml
                ├── layout/
                │   ├── activity_main.xml
                │   ├── fragment_dashboard.xml
                │   ├── fragment_transactions.xml
                │   ├── fragment_add_expense.xml
                │   ├── fragment_add_income.xml
                │   ├── fragment_edit_transaction.xml
                │   ├── fragment_report.xml
                │   ├── fragment_more.xml
                │   └── row_transaction.xml
                ├── menu/
                │   └── bottom_nav_menu.xml
                ├── navigation/
                │   └── nav_graph.xml
                ├── values/
                │   ├── colors.xml
                │   ├── strings.xml
                │   ├── themes.xml
                │   └── dimens.xml
                └── values-sw600dp/
                    └── dimens.xml

Screen Descriptions

1. Dashboard Screen

The Dashboard is the app's home screen and main overview page.

Purpose: Give the user a fast summary of their money activity.

Main UI elements:

Current balance summary
Total income
Total expenses
Savings value
Period selector controls
Previous/next period navigation
Expense/income chart toggle
Donut/pie category chart
Quick Add Expense button
Quick Add Income button
Recent transactions list
See All shortcut to the Transactions screen

Database usage: Reads account balances, income totals, expense totals, category totals, and recent transactions from SQLite.

2. Transactions Screen

The Transactions screen displays the user's recorded money activity.

Purpose: Let users review, search, filter, sort, edit, and delete transaction records.

Main UI elements:

Search field
Transaction summary
Filter controls
Period/account/category/type filters
Sort options
RecyclerView transaction list
Empty-state message when no transactions match the selected filters

Database usage: Reads joined transaction/category/account data from SQLite. Supports deleting transactions and navigating to edit a selected transaction.

3. Add Expense Screen

The Add Expense screen collects information for a new expense transaction.

Purpose: Let users quickly record spending.

Main UI elements:

Amount input
Date selector
Category selector
Account selector
Optional note field
Save Expense button
Back button

Database usage: Inserts a new transaction with type = "expense".

4. Add Income Screen

The Add Income screen collects information for a new income transaction.

Purpose: Let users record salary, freelance income, gifts, refunds, or other money received.

Main UI elements:

Amount input
Date selector
Category selector
Account selector
Optional note field
Save Income button
Back button

Database usage: Inserts a new transaction with type = "income".

5. Edit Transaction Screen

The Edit Transaction screen lets the user change a previously saved transaction.

Purpose: Support correction of mistakes and prototype-level transaction management.

Main UI elements:

Existing amount
Existing date
Existing category
Existing account
Existing note
Update Transaction button
Delete Transaction option
Back button

Database usage: Loads a transaction by ID, updates the record, or deletes the record.

6. Report Screen

The Report screen shows summary analytics for the selected period.

Purpose: Help users understand spending and income patterns visually.

Main UI elements:

Period selector
Income, expense, and savings overview
Category breakdown section
Horizontal category bar chart
Trend line chart
Empty-state message if no data exists for the selected filter

Database usage: Reads grouped totals by category and period-based trend totals from SQLite.

7. More Screen

The More screen contains management and reset tools.

Purpose: Provide app settings, category/account management, and data reset actions.

Main UI elements:

Category management section
Account management section
Add Category option
Add Account option
Reset Transactions option
Reset All Data option
About/overview text

Database usage: Reads, adds, updates, and deletes category/account data where allowed. Prevents deletion when categories or accounts are used by transactions because the database uses foreign key restrictions.

Navigation Design

The app uses Android's Navigation Component with one main activity and multiple fragments.

Navigation Files

File	Purpose
`activity_main.xml`	Contains the `FragmentContainerView` NavHost and bottom navigation
`nav_graph.xml`	Defines fragment destinations and actions
`bottom_nav_menu.xml`	Defines the bottom navigation tabs
`MainActivity.kt`	Connects the bottom navigation to the NavController

Bottom Navigation Tabs

Tab	Destination
Dashboard	`nav_dashboard`
Transactions	`nav_transactions`
Add	Opens a dialog that asks whether to add an Expense or Income
Report	`nav_report`
More	`nav_more`

Navigation Graph Destinations

Destination ID	Fragment
`nav_dashboard`	`DashboardFragment`
`nav_transactions`	`TransactionsFragment`
`nav_report`	`ReportFragment`
`nav_more`	`MoreFragment`
`nav_add_expense`	`AddExpenseFragment`
`nav_add_income`	`AddIncomeFragment`
`nav_edit_transaction`	`EditTransactionFragment`

Navigation Actions

Action	Purpose
`action_dashboard_to_add_expense`	Opens the Add Expense screen from Dashboard
`action_dashboard_to_add_income`	Opens the Add Income screen from Dashboard
`action_dashboard_to_transactions`	Opens the Transactions screen from Dashboard
`action_transactions_to_edit_transaction`	Opens the Edit Transaction screen for a selected transaction

The Edit Transaction destination accepts a transaction_id argument so the controller can load the correct transaction from SQLite.

SQLite Database Design

The app uses a local SQLite database named:

madmoney.db

The database helper is located at:

app/src/main/java/com/example/madmoney/model/MadMoneyDatabaseHelper.kt

The database version is:

DATABASE_VERSION = 1

Foreign key constraints are enabled in onConfigure() to protect relationships between transactions, categories, and accounts.

SQL Schema

`accounts` Table

Stores the money sources or places where money is kept.

CREATE TABLE accounts (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    name TEXT NOT NULL UNIQUE COLLATE NOCASE,
    starting_balance REAL DEFAULT 0,
    icon TEXT NOT NULL DEFAULT 'ic_cash'
);

Column	Type	Description
`id`	INTEGER	Primary key, auto-incremented
`name`	TEXT	Account name, unique case-insensitive value
`starting_balance`	REAL	Starting money amount for that account
`icon`	TEXT	Icon key resolved through `IconCatalog`

`categories` Table

Stores income and expense categories.

CREATE TABLE categories (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    name TEXT NOT NULL COLLATE NOCASE,
    type TEXT NOT NULL,
    icon TEXT NOT NULL DEFAULT 'ic_other',
    color TEXT,
    UNIQUE(name, type)
);

Column	Type	Description
`id`	INTEGER	Primary key, auto-incremented
`name`	TEXT	Category name
`type`	TEXT	Either `income` or `expense`
`icon`	TEXT	Icon key resolved through `IconCatalog`
`color`	TEXT	Hex color used in charts and category displays

The combination of name and type is unique. This allows an income and expense category to share a similar name only when the type is different.

`transactions` Table

Stores the user's income and expense records.

CREATE TABLE transactions (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    type TEXT NOT NULL,
    amount REAL NOT NULL,
    category_id INTEGER NOT NULL,
    account_id INTEGER NOT NULL,
    note TEXT,
    date TEXT NOT NULL,
    created_at TEXT NOT NULL,
    FOREIGN KEY(category_id) REFERENCES categories(id) ON DELETE RESTRICT,
    FOREIGN KEY(account_id) REFERENCES accounts(id) ON DELETE RESTRICT
);

Column	Type	Description
`id`	INTEGER	Primary key, auto-incremented
`type`	TEXT	Either `income` or `expense`
`amount`	REAL	Transaction amount
`category_id`	INTEGER	Foreign key to `categories.id`
`account_id`	INTEGER	Foreign key to `accounts.id`
`note`	TEXT	Optional user note
`date`	TEXT	Transaction date in `yyyy-MM-dd` format
`created_at`	TEXT	Creation timestamp in `yyyy-MM-dd HH:mm:ss` format

Database Relationships

accounts 1 ──── * transactions
categories 1 ── * transactions

Each transaction belongs to exactly one category and exactly one account. Categories and accounts are protected with ON DELETE RESTRICT, so they cannot be removed while related transactions still exist.

Seed Data

The database inserts starter data during onCreate() so the prototype is immediately usable and the charts are visible without requiring the user to enter data first.

Seeded Accounts

Account	Starting Balance	Icon Key
Cash	0.0	`ic_cash`
Bank Account	0.0	`ic_bank`
Digital Wallet	0.0	`ic_phone`
Credit Card	0.0	`ic_card`

Seeded Expense Categories

Category	Type	Icon Key	Color
Food	expense	`ic_food`	`#E53935`
Transport	expense	`ic_transport`	`#1E88E5`
Shopping	expense	`ic_shopping`	`#FB8C00`
Bills & Utilities	expense	`ic_bills`	`#8E24AA`
Health	expense	`ic_health`	`#D81B60`
Entertainment	expense	`ic_entertainment`	`#5E35B1`
Other Expense	expense	`ic_other`	`#757575`

Seeded Income Categories

Category	Type	Icon Key	Color
Salary	income	`ic_salary`	`#43A047`
Freelance	income	`ic_freelance`	`#00897B`
Gift	income	`ic_gift`	`#7CB342`
Refund	income	`ic_refund`	`#039BE5`
Other Income	income	`ic_other`	`#757575`

Seeded Demo Transactions

Type	Amount	Category	Account	Note	Date Offset
income	60000.0	Salary	Bank Account	Monthly salary	Today
income	10000.0	Freelance	Digital Wallet	Client payment	3 days ago
expense	1850.0	Food	Cash	Groceries	Today
expense	350.0	Food	Cash	Lunch	Today
expense	1200.0	Bills & Utilities	Bank Account	Electricity bill	1 day ago
expense	600.0	Transport	Cash	Bus pass	2 days ago
expense	2150.0	Shopping	Credit Card	Online shopping	3 days ago
expense	180.0	Food	Cash	Coffee	4 days ago
expense	3200.0	Health	Bank Account	Pharmacy	8 days ago
expense	900.0	Entertainment	Digital Wallet	Movie	15 days ago
expense	4500.0	Other Expense	Credit Card	Misc	30 days ago

The demo data is intentionally distributed across different dates, categories, and accounts so that dashboard cards, category charts, line charts, filters, and transaction lists can all be demonstrated during the video walkthrough.

Important Database Methods

Method	Purpose
`onCreate()`	Creates tables and inserts default/seed data
`onConfigure()`	Enables foreign key constraints
`addTransaction()`	Inserts a new income or expense transaction
`updateTransaction()`	Updates a selected transaction
`deleteTransaction()`	Deletes a selected transaction
`getTransactions...()` methods	Retrieve joined transaction, category, and account data
`getCategories...()` methods	Retrieve categories by type or all categories
`addCategory()`	Adds a new category
`updateCategory()`	Updates an existing category
`deleteCategory()`	Deletes a category if no transactions use it
`getAccounts...()` methods	Retrieve account data
`addAccount()`	Adds a new account
`updateAccount()`	Updates an account
`deleteAccount()`	Deletes an account if no transactions use it
`resetTransactions()`	Clears transaction rows only
`resetAllData()`	Recreates the database with default seed data

Date Filtering Behavior

Dashboard, Transactions, and Reports share the same date-period behavior.

Filter	Behavior
Day	Shows data for the selected day
Week	Shows data for the week anchored to the selected base date
Month	Shows data for the month anchored to the selected base date
Year	Shows data for the year anchored to the selected base date
All Time	Ignores the selected date and shows all records
Custom Date	Uses a selected start and end date range

The previous and next period arrows move the active date range. This makes the prototype feel closer to a real finance app because users can review different time periods without changing screens.

UI/UX Design Choices

Visual Style

MadMoney uses a clean green finance-themed palette. Green is used for primary branding and income, while red is used for expenses. Neutral grays are used for labels, dividers, and supporting text.

Color Resources

Resource	Value	Usage
`green_primary`	`#2E7D32`	Primary app color
`green_dark`	`#1B5E20`	Dark primary variant
`green_light`	`#E8F5E9`	Light green background/accent
`income_green`	`#2E7D32`	Income values
`expense_red`	`#D32F2F`	Expense values
`expense_light`	`#FFEBEE`	Light expense highlight
`text_dark`	`#212121`	Primary text
`text_gray`	`#757575`	Secondary text
`divider_gray`	`#E0E0E0`	Dividers and borders
`background_light`	`#F7FAF7`	Main light background

Theme

The app theme is defined in themes.xml and extends:

Theme.MaterialComponents.DayNight.NoActionBar

This provides a modern Material base while allowing the project to control the screen layout through custom XML and bottom navigation.

Typography and Spacing

The app uses the Android sans font family and centralized dimension resources. Important layout spacing values are kept in dimens.xml rather than hardcoded repeatedly.

Responsiveness

The app supports different screen widths using standard Android resource qualifiers.

File	Purpose
`res/values/dimens.xml`	Default phone dimensions
`res/values-sw600dp/dimens.xml`	Larger spacing and chart heights for wider screens/tablets

Examples of responsive resources:

Dimension	Default	`sw600dp`
`screen_horizontal_padding`	`20dp`	`32dp`
`form_control_min_height`	`52dp`	`56dp`
`primary_button_height`	`56dp`	`58dp`
`chart_height`	`220dp`	`280dp`
`large_chart_height`	`230dp`	`300dp`
`note_field_min_height`	`96dp`	`120dp`
`chart_card_padding`	`12dp`	`18dp`
`dashboard_pie_chart_height`	`360dp`	`430dp`

This supports the rubric's responsiveness requirement by avoiding fixed assumptions about one phone size.

Resource Management

The project uses Android resource files to improve maintainability.

Resource File	Purpose
`strings.xml`	Stores screen titles, labels, button text, messages, hints, errors, and empty states
`colors.xml`	Stores reusable app colors
`themes.xml`	Stores theme and Material styling settings
`dimens.xml`	Stores reusable dimensions for spacing, charts, buttons, and forms
`bottom_nav_menu.xml`	Stores bottom navigation items
`nav_graph.xml`	Stores navigation destinations and actions
`drawable/`	Stores launcher/vector drawable resources

Using resources makes the app easier to maintain, localize, and update because UI text and styles are not scattered throughout the Kotlin files.

Icon System

All selectable icons are managed through:

app/src/main/java/com/example/madmoney/util/IconCatalog.kt

The app stores icon keys, such as ic_food, ic_bank, ic_card, or ic_other, in SQLite. UI screens then resolve those keys through IconCatalog when displaying category or account icons.

This approach keeps the database lightweight and prevents the app from storing images directly in SQLite. It also means that the same category/account icon can appear consistently in:

Dashboard chart callouts
Dashboard recent transaction rows
Reports category rows
Transactions list rows
Add Expense spinner
Add Income spinner
Edit Transaction spinner
More screen category/account management rows

Data Flow Example

Adding an Expense

User opens Add tab
        ↓
MainActivity shows Add Expense / Add Income dialog
        ↓
User selects Add Expense
        ↓
NavController opens AddExpenseFragment
        ↓
User enters amount, date, category, account, and note
        ↓
AddExpenseFragment validates input
        ↓
AddExpenseFragment creates a Transaction model object
        ↓
MadMoneyDatabaseHelper.addTransaction() inserts the row into SQLite
        ↓
User returns to Transactions/Dashboard and sees updated data

Viewing Reports

User opens Report tab
        ↓
ReportFragment reads selected date filter
        ↓
DateFilterUtils calculates the date range
        ↓
MadMoneyDatabaseHelper queries grouped transaction totals
        ↓
ReportFragment updates summary cards and chart views
        ↓
HorizontalBarChartView and LineChartView draw visual reports

How This Project Connects to zyBooks / Course Concepts

The project applies major Android development concepts typically covered in zyBooks Android/Kotlin chapters and course modules. Chapter numbers may vary by class section, but the concepts are represented in the code as follows.

zyBooks / Course Concept	Where It Appears in MadMoney	Explanation
Android project structure	Entire `MadMoney/` project	Uses Gradle, AndroidManifest, app module, resource folders, Kotlin source folders, and wrapper files
Activities	`MainActivity.kt`	Main activity hosts the app and controls the navigation container
Fragments	`DashboardFragment.kt`, `TransactionsFragment.kt`, `ReportFragment.kt`, etc.	Each major app screen is implemented as a fragment
XML layouts	`res/layout/*.xml`	UI screens are designed using Android XML layout resources
Views and widgets	Layout XML files	Buttons, text fields, RecyclerView, chart containers, filter controls, and navigation widgets are used throughout the app
Event handling	Fragment controller classes	Click listeners, dialog selections, save/update/delete buttons, search/filter controls, and navigation actions respond to user input
Navigation Component	`nav_graph.xml`, `MainActivity.kt`, `bottom_nav_menu.xml`	The app uses a NavHost, NavController, fragment destinations, and navigation actions
Menus	`bottom_nav_menu.xml`	Bottom navigation items are defined in a menu XML resource
RecyclerView and Adapter pattern	`TransactionsFragment.kt`, `TransactionAdapter.kt`, `row_transaction.xml`	Transaction data is displayed in a scrollable list using an adapter and reusable row layout
Data classes	`Transaction.kt`, `Category.kt`, `Account.kt`	Kotlin data classes represent app data objects
SQLite databases	`MadMoneyDatabaseHelper.kt`	The app creates tables, inserts seed data, queries rows, updates records, and deletes records
CRUD operations	`MadMoneyDatabaseHelper.kt` and controller fragments	Users can create, read, update, and delete transactions; categories and accounts are also managed
Strings and resources	`strings.xml`, `colors.xml`, `dimens.xml`, `themes.xml`	UI text, colors, spacing, and themes are stored in resource files
Responsive design	`values/dimens.xml`, `values-sw600dp/dimens.xml`, ConstraintLayout use	The UI adjusts spacing and chart sizes for different screen widths
Material Design	Material Components dependency and theme	Bottom navigation, dialogs, and visual styling use Material design conventions
MVC design pattern	`model/`, `view/`, `controller/` packages	The project separates data, UI, and screen-control logic
Input validation	Add/Edit fragments	Amounts and required selections are checked before saving
Custom views	`CategoryPieChartView.kt`, `HorizontalBarChartView.kt`, `LineChartView.kt`	The app includes custom-drawn chart components
Code organization and naming	Package structure and file names	Files are grouped by responsibility and named according to their purpose

Rubric Alignment

Requirement	How MadMoney Addresses It
UI Completeness	Includes Dashboard, Transactions, Add Expense, Add Income, Edit Transaction, Report, and More screens
Navigation Functionality	Uses `nav_graph.xml`, `NavHostFragment`, `NavController`, bottom navigation, and fragment actions
Visual Design Consistency	Uses consistent green finance theme, shared colors, shared dimensions, and repeated card/list patterns
Responsiveness	Uses ConstraintLayout, ScrollViews where needed, and `values-sw600dp` dimension resources
Use of Resources	Uses `strings.xml`, `colors.xml`, `themes.xml`, `dimens.xml`, `menu`, `navigation`, and drawable resources
Code Organization	Uses separate `model`, `view`, `controller`, `adapter`, and `util` packages
Video Walkthrough	Demo should show all screens, navigation, form inputs, filters, charts, edit/delete, and management screens
README File	This README explains the app purpose, architecture, screens, database schema, seed data, resources, and course concept alignment
Creativity and Aesthetic Appeal	Includes chart views, icon-based categories/accounts, summary cards, and finance-themed color choices

Testing Checklist

tested the following items:

Video Link

Add the final video walkthrough link here before submitting:

Video walkthrough: [PASTE YOUTUBE, GOOGLE DRIVE, OR ATTACHED FILE LINK HERE]

Known Limitations

This is a course prototype, not a production finance app.
Data is stored locally on the device using SQLite.
There is no cloud backup or user account login.
The app does not connect to real bank accounts.
Charts are prototype visualizations based on local transaction records.
Currency formatting is handled locally and can be expanded in the final version.

Future Improvements

Potential final-project improvements include:

User login and profile settings
Budget goals by category
Monthly spending alerts
Export transactions to CSV or PDF
Recurring transactions
Cloud backup or Firebase integration
Dark mode refinements
More chart types
Account transfer support
Improved tablet layout with two-pane screens

Name		Name	Last commit message	Last commit date
Latest commit History 2 Commits
Docs		Docs
MadMoneyMobile		MadMoneyMobile

Folders and files

Latest commit

History

Repository files navigation

MadMoney Mobile

Project Overview

App Purpose

Prototype Scope

Included in This Prototype

Not Included / Future Final-App Work

How to Open and Run the Project

Recommended Environment

Major Dependencies

MVC Architecture

MVC Role Breakdown

Model Layer

View Layer

Controller Layer

Adapter Layer

Utility Layer

Project File Structure

Screen Descriptions

1. Dashboard Screen

2. Transactions Screen

3. Add Expense Screen

4. Add Income Screen

5. Edit Transaction Screen

6. Report Screen

7. More Screen

Navigation Design

Navigation Files

Bottom Navigation Tabs

Navigation Graph Destinations

Navigation Actions

SQLite Database Design

SQL Schema

accounts Table

categories Table

transactions Table

Database Relationships

Seed Data

Seeded Accounts

Seeded Expense Categories

Seeded Income Categories

Seeded Demo Transactions

Important Database Methods

Date Filtering Behavior

UI/UX Design Choices

Visual Style

Color Resources

Theme

Typography and Spacing

Responsiveness

Resource Management

Icon System

Data Flow Example

Adding an Expense

Viewing Reports

How This Project Connects to zyBooks / Course Concepts

Rubric Alignment

Testing Checklist

Video Link

Known Limitations

Future Improvements

About

Resources

Uh oh!

Stars

Watchers

Forks

Releases

Packages 0

Uh oh!

Contributors

Uh oh!

Languages

`accounts` Table

`categories` Table

`transactions` Table

Packages