Chapter 1

INTRODUCTION

One of the most important things you can do when trying to get your personal finances under
control is to figure out WHERE all of your money is going each month. If you start off by
tracking your expenses each day, you will be able to get a better idea of where your money is
going.

For young adults especially, keeping track of spending is something nearly everyone can benefit
from. It doesn’t take much for someone to get off track and start getting caught up in their
finances by overspending. Having a handle on what is going in and out lets people see the reality
of their finances, and most would agree that getting started right away is best. Keeping track of
expenses and financial information means a person will always be aware of where their money is
and what is happening with it, so anything unexpected is dealt with quickly, and is much easier
to handle.

ExpenseTracker is an Android app for mobile devices. It is a simple and user friendly Android
app to track expenses. Each user will be required to register on the app and add his expenses
based on categories provided by the app. The app will generate monthly report based on Expense
category via multiple graphs like Bar Chart and Pie Chart.
Objectives
1. ExpenseTracker app makes managing money easier and allows a person to be in total
control of their finances and their financial future.
2. It helps users manage their money more effectively and bring discipline in all money
related matters.
3. The app helps to stop the spending impulses.
4. It remove needless purchases.
5. It forces the user to focus on what their money is worth.
6. It prevents anyone from going into debt.

Scope of the project

It is a good idea to spend according to what is needed or valued most first, which is a difficult
thing to do without keeping track of the actual figures. Without keeping track, too much money
may be getting spent shopping at the store instead of going into a savings account for that dream
family vacation you want to take next year.
It is easy to start living beyond one’s means when you do not pay attention to what you are
spending all of your hard-earned money on, which is how people start to acquire debt. Anyone
who is in debt or has been in debt knows how difficult it can be to climb out of that hole. When
you know where your money is going and has a handle on your finances, you can start setting
financial goals. Such as a goal to put away specific amounts each week or month, or have a
certain number saved by the end of the year.

By keeping track of where and when money is being spent, it’s much easier to see any bad
spending habits that can be worked on. When you are able to see where your spending
weaknesses are, you can begin to make changes to correct them. This understanding may be
enough to correct a bad spending habit by making someone question their future purchases and
see if they are actually necessary.
Chapter 2

LITERATURE REVIEW

ANDROID OPERATING SYSTEM

When Android first arrived in 2008, it was almost seen as a poor relation to the much more
stylish iOS on Apple iPhone. But, quite quickly, through diverse handset offers that struck a
chord with both the practical price-conscious as well as the fashion-conscious and tech hungry
consumers, Android user numbers exploded. Now, after eight major releases, the annual sales of
Android devices is increasing almost every year.

The reason developing for Android gives such a buzz is the nature of the devices. They are
deeply personal. We can create apps that actually interact with people's lives. We can educate,
entertain, organize and so on. Everyone uses them, from infants to seniors.

Android is an open source and Linux-based Operating System for mobile devices such as
Smartphone and tablet computers. Android was developed by the Open Handset Alliance, led by
Google, and other companies. Android offers a unified approach to application development for
mobile devices which means developers need to develop only for Android, and their applications
should be able to run on different devices powered by Android. The first beta version of the
Android Software Development Kit (SDK) was released by Google in 2007, whereas the first
commercial version, Android 1.0, was released in September 2008. The source code for Android
is available under free and open source software licenses. Google publishes most of the code
under the Apache License version 2.0 and the rest, Linux kernel changes, under the GNU
General Public License version 2
Android Logo
Android Versions
2.1.3. Architecture

Android operating system is a stack of software components as shown below in the architecture
diagram.
 System Apps - The Android Open Source Project contains several default applications like
the Browser, Camera, Gallery, Music, Phone and more.
 Java API framework -. The Application Framework layer provides many higher-level
services to applications in the form of Java classes. Application developers are allowed to
make use of these services in their applications
 Android runtime - This is the third section of the architecture and available on the second
layer from the bottom. This section provides a key component called Dalvik Virtual
Machine which is a kind of Java Virtual Machine specially designed and optimized for
Android. The Dalvik VM makes use of Linux core features like memory management and
multi-threading, which is intrinsic in the Java language. The Dalvik VM enables every
Android application to run in its own process, with its own instance of the Dalvik virtual
machine. The Android runtime also provides a set of core libraries which enable Android
application developers to write Android applications using standard Java programming
language
 Libraries – On top of Linux kernel there is a set of libraries including open-source Web
browser engine WebKit, well known library libc, SQLite database which is a useful
repository for storage and sharing of application data, libraries to play and record audio and
video, SSL libraries responsible for Internet security etc.
 Hardware Abstraction Layer (HAL) - The hardware abstraction layer (HAL) provides
standard interfaces that expose device hardware capabilities to the higher-level Java API
framework. The HAL consists of multiple library modules, each of which implements an
interface for a specific type of hardware component, such as the camera or bluetooth module.
When a framework API makes a call to access device hardware, the Android system loads
the library module for that hardware component
 Linux kernel - Communication layer for the underlying hardware. A kernel is the first layer
of software that interacts with the device hardware. The kernel is responsible for providing
basic architectural model for process scheduling, resource handling, memory management,
networking and isolation etc. Android uses the Linux kernel under the hood. Because Linux
is open-source, Google’s Android developers could modify the Linux kernel to fit their
 needs. Linux gives the Android developers a pre-built, already maintained operating system
kernel to start with so they don’t have to write their own kernel.

Android Applications

An Android app is a software application running on the Android OS. Most Android apps are
uploaded and published on the Google Play Store, an online store dedicated to these applications.
The Play Store features both free and priced apps. The extension of Android application is .apk
APK stands for Application package file. APK files contain the code files, resource files and the
AndroidManifest.xml file. AndroidManifest.xml contains info about the app.

Android Activity Life Cycle

The Activity class is a crucial component of an Android app, and the way activities are launched
and put together is a fundamental part of the platform's application model. Unlike programming
paradigms in which apps are launched with a main() method, the Android system initiates code
in an Activity instance by invoking specific callback methods that correspond to specific stages
of its lifecycle.

Activities in the system are managed as an activity stack. When a new activity is started, it is
placed on the top of the stack and becomes the running activity -- the previous activity always
remains below it in the stack, and will not come to the foreground again until the new activity
exits.

An activity has essentially four states:

1. If an activity is in the foreground of the screen (at the top of the stack), it is active or
running.
2. If an activity has lost focus but is still visible (that is, a new non-full-sized or transparent
activity has focus on top of your activity), it is paused. A paused activity is completely
alive (it maintains all state and member information and remains attached to the window
manager), but can be killed by the system in extreme low memory situations.
 3. If an activity is completely obscured by another activity, it is stopped. It still retains all
state and member information, however, it is no longer visible to the user so its window
is hidden and it will often be killed by the system when memory is needed elsewhere.
4. If an activity is paused or stopped, the system can drop the activity from memory by
either asking it to finish, or simply killing its process. When it is displayed again to the
user, it must be completely restarted and restored to its previous state.

To navigate transitions between stages of the activity lifecycle, the Activity class provides a core
set of six callbacks: onCreate(), onStart(), onResume(), onPause(), onStop(), and onDestroy().
The system invokes each of these callbacks as an activity enters a new state.

The square rectangles represent callback methods you can implement to perform operations
when the Activity moves between states. The colored ovals are major states the Activity can be
in.
There are three key loops you may be interested in monitoring within your activity:

The entire lifetime of an activity happens between the first call to onCreate(Bundle) through to a
single final call to onDestroy(). An activity will do all setup of "global" state in onCreate(), and
release all remaining resources in onDestroy().

The visible lifetime of an activity happens between a call to onStart() until a corresponding call
to onStop(). During this time the user can see the activity on-screen, though it may not be in the
foreground and interacting with the user. Between these two methods you can maintain resources
that are needed to show the activity to the user.

The foreground lifetime of an activity happens between a call to onResume() until a

corresponding call to onPause(). During this time the activity is in front of all other activities and
interacting with the user. An activity can frequently go between the resumed and paused states.

Android Studio

Android Studio is the official IDE (Integrated Development Environment) for the Android
platform, developed by Google and used to make the majority of the apps.

Android Studio was first announced at a Google I/O conference in 2013 and was released to the
general public in 2014 after various beta versions. The current stable version is 3.0 released in
October 2017.
As an IDE, Android Studio’s job is to provide the interface for developers to create their apps
and to handle much of the complicated file-management behind the scenes. Android Studio is
simply where developers will write, edit and save their projects and the files that comprise said
projects. At the same time, Android Studio gives access to the Android SDK or ‘Software
Development Kit’. Android Studio also enables to run the code, either through an emulator or
through a piece of hardware connected to the machine.

SQLite Database Service

SQLite is a relational database management system, similar to Oracle, MySQL, PostgreSQL and
SQL Server. It implements most of the SQL standard, but unlike the four database engines
mentioned above, it is not a client-server database engine. Rather, it is embedded into the end
program. What this means is that you can bundle a SQLite database with your application, and
get access to all the power of a relational database within your application. SQLite is native to
both Android and iOS, and every app can create and use an SQLite database if they so desire. In
fact, in Android, device contacts, and media are stored and referenced using SQLite databases.

JAVA
Java is a language that allows us to write code once that can be used over and over again. This is
very useful because it saves us time and allows us to use other people's code to perform tasks we
might otherwise not have the time or knowledge to write for ourselves. Most of the time, we do
not even need to see this code or even know how it does its work!

Java is a programming language that has been around a lot longer than Android. It is an object-
oriented language.

The primary motivation of this language was the need for a platform-independent (i.e.
architecture neutral) language that could be used to create software to be embedded in various
consumer electronic devices.

• Java is a programmer’s language

• Java is cohesive and consistent
• Except for those constraint imposed by the Internet environment.
 • Java is a known language, developers know it and don't have to learn it
• It is harder to shoot yourself with Java than with C/C++ code since it has no pointer
arithmetic
• It runs in a VM, so no need to recompile it for every phone out there and easy to
secure
• There are a large number of development tools for Java
• Several mobile phones already used Java ME, so Java was known in the industry
• There are a large number of developers already proficient in Java.
• Java has huge open source support, with many libraries and tools available to make
developers life easier.
• Java protects you from many of the problems inherent in native code, like memory
leaks, bad pointer usage, etc.
• Java allows them to create sandbox applications, and create a better security model so
that one bad App can't take down your entire OS.

2.2.1 Java Architecture

Java architecture provides a portable, robust, high performing environment for development.
Java provides portability by compiling the byte codes for the Java Virtual Machine, which is then
interpreted on each platform by the run-time environment. Java is a dynamic system, able to load
code when needed from a machine in the same room or across the planet.

Compilation of code - When you compile the code, the Java compiler creates machine code
(called byte code) for a hypothetical machine called Java Virtual Machine (JVM). The JVM is
created for overcoming the issue of probability. The code is written and compiled for one
machine and interpreted on all machines. This machine is called Java Virtual Machine.

XML

A markup language is a mechanism to identify structures in a document. XML (Extensible

Markup language) is a markup language for documents containing structured information. As a
meta-language, XML is about to describe data and its structure; while HTML is about to display
the data.
XML is not to replace HTML, but compliment it by allowing writers to create and format their
own document markups. For HTML, The tags used to mark up HTML documents and the
structure of HTML documents are predefined. For XML, there is no predefined tag set, so there
is no any preconceived semantics. Writers are provided a facility to define tags and the structural
relationships. That is the extensible feature of XML.

To be valid, XML documents should be well-formed. That means XML documents follow some
strict rules. For example, every opening tag in XML documents must have a matching closing
tag. While in HTML, pairing is optional for some of the tags, and only the opening tag is
required.

Some rules for composing XML documents:

1. Closing Tags

An element in XML must have a closing tag.

For example:

<firstname>James</firstname>

2. Overlapping Elements

An element must be nested properly by closing all child elements before closing the parent
elements.

For example:

<student>

<firstname>James</firstname>

<lastname>Smith</lastname>

</student>

It would be incorrectly nested if the student element was closed before forename element.
3. Single Root Element

An XML document only can have a single root element. All other elements should be within this
root element.

For example:

<mec>

<student>

<firstname>James</firstname>

<lastname>Smith</lastname>

</student>

</mec>

As above, mec is the root element, and student is its descendant.

4. Case Sensitive

XML is case sensitive, and care should be taken to ensure that Opening and closing tags are in
the same case. An element name of "MEC" is not the same as "mec".

5. Quoted Attribute Values

In XML, attributes must be specified a value, and the values must be in quotes, regardless of the
data type. Single and double quotes are both acceptable.

For example:

Correct: <input type="checkbox" checked="checked"/>

Wrong: <input type="checkbox" checked>

6. Naming Conventions

In XML, since there is no any pre-defined tag, there are no reserved words needed to be avoided
when naming elements. The following are some simple rules when naming an element.

a. Elements must start with a character or an underscore but not a number or punctuation. After
the first character, numbers, hyphens and periods are allowed.

b. Names must not contain spaces.

c. A colon is reserved for namespaces

Chapter 3

SYSTEM REQUIREMENTS

EXISTING SYSTEM

Everyone has a love-hate relationship with money. We need it to buy those things that we need,
but keeping a hold of it can be a real pain. Managing day to day expenses is one of the most
tedious tasks. One way to track our expenses is to simply write down every penny that we spend
and where we spent it in a notebook. However this is cumbersome and difficult to maintain. All
the calculations needs to be done by the user which may sometimes results in errors leading to
losses.

If you can track your expenses religiously, you can actually reduce your expenditures and start
saving. But it's so hard to actually track down every one of your expenditure and keep a tab on
all of it. That's where expense trackers come in handy. Today almost everyone owes a
smartphone and mobile applications form the backbone of smartphones. In this day & age, the
best way to manage expenses is to use an app.

Instead of keeping a dairy or a log of the expenses on the smartphones or laptops,

ExpenseTracker app enables the user to not just keep the tab on the expenses but also to plan
ahead keeping the past budget in mind. The app attempts to free the user from the burden of
manual calculation and helps to keep track of the expenditure.

PROPOSED SYSTEM

The proposed system has the following advantages:

1. ExpenseTracker app makes tracking expenses easy and simple.
2. It is not time consuming. Fewest taps are necessary to create an expense.
 3. This app is ideal for people who hate paperwork.
4. The app generates a pie chart and bar chart of the expenses, to give a visual of where the
user is spending his income. This is visually appealing to the user.
5. The app is localized for Kannada and Hindi languages.
6. The user can send the details of his monthly expenses in the form of mail to his registered
mail id and in the form of SMS to his registered mobile number.

General requirements

1. Users should feel right at home with the app on their device. UI should not be ported
from other platforms.
2. The different screens should be consistent throughout the app.
3. There should not be spelling mistakes in the text displayed on the screens of the app.
4. Text should be readable. Small font sizes should not be used.
5. px units should not be used for layout dimensions. dp should be used for layout
dimensions and sp for text font size
6. Modal progress and confirmation dialogs should not be overused.
7. Proper margins and padding have to be used in the layout design.
8. Theme, style, color, string resources have to be used to reduce redundancy.
9. Proper feedback should be given to the user when using the app.
10. The most common operations should be immediately visible and available. Secondary
functionality can be reserved for Menu.
11. Appropriate error messages should be displayed when invalid data is entered.

System goals

1. No formal knowledge is required by the user to use the app. Hence it is user friendly.
2. The app gives more security to data, ensures data accuracy, reduces paper work and saves
time.
3. The app is less prone to errors as it avoids errors as much as possible while entering data.
Also appropriate error messages are displayed when invalid data is entered.
4. It makes information flow efficient and paves way for easy report generation. As a result
the proposed system is cost effective.
5. The app leads to error free, secure, reliable and fast management system.
6. It helps the user in better utilization of his income as manual record keeping is
completely eliminated.
FUNCTIONAL REQUIREMENTS

It defines the functionality of the software and the constraints on it. Functional requirements
describe the features, functioning, and usage of a product/system/software from the perspective
of the product and its user. The document will not only define the product functions, user
characteristics and constraints but also serve as a basis for software design document.

MODULES OF THE PROJECT:

1. Splash Screen

2. Support for Kannada and Hindi languages

3. Registration

4. Login

5. Forgot Password

6. Add Income – Income details include

a. Amount

b. Date

7. Add Expense - Expense details include

a. Description

b. Category

c. Amount

d. Date

8. Viewing all the expenses of a user

9. Viewing monthly expenses of a user

 10. Delete Expense

11. Reports – Bar Chart and Pie Chart

12. Saving user details & preferences in a SQLite database

13. Menu items

 Logout

 About Us

 Change Password

 Send mail and SMS

NON FUNCTIONAL REQUIREMENTS

These are the requirements that specifies criteria that can be used to judge the operation of a
system, rather than specific behaviors. These are constraints within which the system must work.
The non-functional requirement elaborates a performance characteristic of the system.

Performance
The app must be interactive and the delays involved must be less. So in every action-response of
the app, there are no immediate delays. Resource consumption of this application should not
reach an amount that renders the mobile device unusable. The application should be capable of
operating in the background should the user wish to utilize other applications.

Usability
The app must be easy to handle and navigate in the most expected way with no delays. The app
should transverse quickly between its states.

Reliability
The app should meet all of the functional requirements without any unexpected behavior. At no
time should the gauge output display incorrect or outdated information without alerting the user
to potential errors. The app is less prone to errors as it avoids errors as much as possible while
entering data. Also appropriate error messages are displayed when invalid data is entered.
Availability
The app will be available at all times on the user’s Android device, as long as the device is in
proper working order.

Maintainability
The software should be written clearly and concisely. The code will be well documented.
Particular care will be taken to design the software modularly to ensure that maintenance is easy.

Portability
This software will be designed to run on any Android operating system version 4.0 or higher.
The software will be forward compatible for all currently released Android operating system
versions (up to 7).

Response time
The time taken by the system to complete a task given by the user must be very less. The
application must respond instantly to the task requested.

FEASIBILITY STUDY

Feasibility study is a procedure that identifies, describes and evaluates candidate android
application and selects the best application feature for the job. An estimate is made whether the
identified users need may be satisfied using the current networking facilities and hardware
technologies. The study will decide whether the proposed android application will be cost
effective from a business point of view and if it can be developed using the given existing
budgetary constraints.
The key considerations involved in the feasibility analysis of our proposed application are the
following:
 Operational Feasibility
 Technical Feasibility
 Economic Feasibility
 Schedule Feasibility

Operational Feasibility

Operational feasibility is necessary as it ensures that the project developed is a successful one.
The operational feasibility of this project is high since it is user friendly and the application
provides all the expected outputs to the user.

Technical Feasibility

Technical feasibility analysis makes a comparison between the level of technology available and
that is needed for the development of the project. The level of technology consists of the factors
like software tools, and platform developed and so on. Since, the resources for the development
of the project is available, the project is technically feasible.

Economic Feasibility

This is the most important part of the project because the terms and conditions for implementing
the project have to be economically feasible. The risk of finance does not exist as the existing
hardware that is smart phone is sufficient and the software is free of cost. So, it is believed that
the system is economically feasible.

Schedule Feasibility
Schedule feasibility is defined as the likelihood of a project being completed within its desired
timeframe. Since this project has a high likelihood of completion by the desired due date,
schedule feasibility is considered to be high.
SOFTWARE REQUIREMENTS

Operating System Windows 7 or higher

Languages Used Java, XML

Development Environment (IDE) Android Studio

Database SQLite

HARDWARE REQUIREMENTS

Hard disk Minimum of 40GB

RAM 4 GB or higher

Device Android mobile

Chapter4

SYSTEM ARCHITECTURE
In Expense Tracker app, the User has to register with the app with his details and then he can
Login to the system. After logging in a User can add his expenses and income. The user can view
his monthly expenses or list all the expenses. It is possible to delete expenses from the list. The
user can also view reports of his expenses in the form of Pie Chart or Bar Chart.
FLOW CHART
A flowchart is a type of diagram that represents an algorithm, workflow or process, showing the
steps as boxes of various kinds, and their order by connecting them with arrows.

Flowchart Symbols and notation:

1. Start and end symbols, represented as ovals or rounded rectangles, usually containing the
word "Start" or "End", or another phrase signaling the start or end of a process.
2. Arrows, showing what's called "flow of control". An arrow coming from one symbol and
ending at another symbol signifies flow passes to the symbol the arrow points to.
3. Processing steps, represented as rectangles.
4. Conditional (or decision), represented as a diamond (rhombus). These typically contain a
Yes/No question or True/False test. This symbol is unique in that it has two arrows
coming out of it, usually from the bottom point and right point, one corresponding to Yes
or True, and one corresponding to No or False. The arrows should always be labeled.
If the user is new to the app, then he has to register with the app. The app requires details like
name, mail id, contact number, password for registration. Upon successful registration, the user
can add expensse and income, delete expensse and view monthly expenses or all expenses.
Chapter 5

SYSTEM DESIGN

The design document that we develop during this phase is the blueprint of the software. It
describes how the solution to the customer problem is to be built. The design activity begins
when the requirements document for the software to be developed is available. While the
requirements specification activity is entirely in the problem domain, design is the first step in
moving from the problem domain toward the solution domain. Design is essentially the bridge
between requirements specification and the final solution for satisfying the requirements.

The design of a system is essentially a blueprint or a plan for a solution for the system. The
design process for software systems, often, has two levels. At the first level, the focus is on
deciding which modules are needed for the system, the specifications of these modules, and how
the modules should be interconnected. This is what is called the system design or top-level
design. In the second level, the internal design of the modules, or how the specifications of the
module can be satisfied, is decided. This design level is often called detailed design or logic
design. Detailed design essentially expands the system design to contain a more detailed
description of the processing logic and data structures so that the design is sufficiently complete
for coding.
DATA FLOW DIAGRAM

A data flow diagram (DFD) maps out the flow of information for any process or system. It uses
defined symbols like rectangles, circles and arrows, plus short text labels, to show data inputs,
outputs, storage points and the routes between each destination. Data flowcharts can range from
simple, even hand-drawn process overviews, to in-depth, multi-level DFDs that dig progressively
deeper into how the data is handled. They can be used to analyze an existing system or model a
new one. Like all the best diagrams and charts, a DFD can often visually “say” things that would
be hard to explain in words, and they work for both technical and nontechnical audiences, from
developer to CEO.

DFD rules and tips

 Each process should have at least one input and an output.

 Each data store should have at least one data flow in and one data flow out.
 Data stored in a system must go through a process.
 All processes in a DFD go to another process or a data store.

DFD levels

A data flow diagram can dive into progressively more detail by using levels and layers, zeroing
in on a particular piece. DFD levels are numbered 0, 1 or 2, and occasionally go to even Level 3
or beyond. The necessary level of detail depends on the scope of what you are trying to
accomplish.

DFD Level 0 is also called a Context Diagram. It’s a basic overview of the whole system or
process being analyzed or modeled. It’s designed to be an at-a-glance view, showing the system
as a single high-level process, with its relationship to external entities. It should be easily
understood by a wide audience, including stakeholders, business analysts, data analysts and
developers.
DFD Level 1 provides a more detailed breakout of pieces of the Context Level Diagram. You
will highlight the main functions carried out by the system, as you break down the high-level
process of the Context Diagram into its sub processes.

DFD Level 2 then goes one step deeper into parts of Level 1. It may require more text to reach
the necessary level of detail about the system’s functioning.

Level 0 DFD

The Level 0 DFD shows the Expense Tracker App as a high level process with the main entity
User.
Level 1 DFD – Login and Registration

Level 1 DFD – Adding Income and Expense

 Level 1 DFD – Viewing Expenses and Reports

In the Level 1 DFD the entire system is divided into various processes like Login, Registration,
Adding Income, Adding Expense, Viewing Expenses and Reports
ACTIVITY DIAGRAMS

The major activities of the Expense Tracker application are depicted here.
USE CASE DIAGRAMS

A use case diagram is a graphical representation of the user’s interaction with the system. It can
portray the different types of users of a system and the various ways they interact with the
system. Use cases are diagrammed to be easily understood, no matter who is looking at the
diagram.

A use case diagram can summarize the details of your system's users (also known as actors) and
their interactions with the system. An effective use case diagram helps to represent:

1. Scenarios in which your system or application interacts with people, organizations, or

external systems
2. Goals that it helps those entities (known as actors) achieve
3. The scope of your system

Purpose of Use Case Diagrams:

1. To demonstrate the different ways that a user might interact with a system.
2. To gather the requirements of a system.
3. To get an outside view of a system.
4. To identify the external and internal factors influencing the system.

Use Case Diagram Components:

1. Actors - the users that interact with a system. An actor can be a person, an organization,
or an outside system that interacts with your application or system. They must be external
objects that produce or consume data.
2. System - a specific sequence of actions and interactions between actors and the system.
A system may also be referred to as a scenario.
 3. Goals - the end result of most use cases. A successful diagram should describe the
activities and variants used to reach the goal.

Use Case Diagram Symbols and Notation:

Use case diagrams consists of actors, use cases and their relationships.

1. Use cases - Use cases are the horizontally shaped ovals. This represents the different uses
that a user might need.
2. Actors - represented by stick figure people and are the people actually employing the use
cases
3. Associations - represented by a line between actors and use cases.
Advantages of Use Case Diagrams:

1. A use case diagram helps provide a high level view of the system
2. It provides a simplified graphical representation of what the system must actually do
3. Use case diagrams are a good communication tool for stakeholders

User has to register with the app with his details and then he can Login to the system. After
logging in a user can add his monthly income and expenses. In addition to this he can also view
expenses and reports. The app also provides option to mail and SMS monthly expenses.
ER DIAGRAM

An Entity Relationship (ER) Diagram is a type of flowchart that illustrates how “entities” such as
people, objects or concepts relate to each other within a system. ER Diagrams are most often
used to design or debug relational databases in the fields of software engineering, business
information systems, education and research. Also known as ERDs or ER Models, they use a
defined set of symbols such as rectangles, diamonds, ovals and connecting lines to depict the
interconnectedness of entities, relationships and their attributes. They mirror grammatical
structure, with entities as nouns and relationships as verbs.
Chapter 6

IMPLEMENTATION

6.1 SOFTWARE TOOLS USED

Android Studio

6.2 PROGRAMMING TECHNOLOGY

JAVA
XML
Android programming

6.3 ANDROID PROJECT IMPLEMENTATION

REQUIREMENTS

6.3.1 Application Android Manifest

Every application must have an AndroidManifest.xml file (with precisely that name) in its root
directory. The manifest file provides essential information about your app to the Android system,
which the system must have before it can run any of the app's code.
Among other things, the manifest file does the following:

 It names the Java package for the application. The package name serves as a unique
identifier for the application.
 It describes the components of the application, which include the activities, services,
broadcast receivers, and content providers that compose the application. It also names the
classes that implement each of the components and publishes their capabilities, such as
the Intent messages that they can handle. These declarations inform the Android system
of the components and the conditions in which they can be launched.
 It determines the processes that host the application components.
 It declares the permissions that the application must have in order to access protected
parts of the API and interact with other applications. It also declares the permissions that
others are required to have in order to interact with the application's components.
 It lists the Instrumentation classes that provide profiling and other information as the
application runs. These declarations are present in the manifest only while the application
is being developed and are removed before the application is published.
 It declares the minimum level of the Android API that the application requires.
 It lists the libraries that the application must be linked against.
 6.3.2 Architecture

The project is based on MVC architecture where the application is divided into three logical
constituents-

 View – Provide services such as user interface. The user interface is designed using the
XML language.
 Controller – Implement business logic. The activity classes are used as controllers for the
different layouts.
 Model – Provide handling and validation of data. (Java objects in this case)
 6.3.3 Application Layouts

A layout defines the visual structure for a user interface, such as the UI for an activity or app
widget. You can declare a layout in two ways:

Declare UI elements in XML. Android provides a straightforward XML vocabulary that

corresponds to the View classes and subclasses, such as those for widgets and layouts.

Instantiate layout elements at runtime. Your application can create View and ViewGroup
objects (and manipulate their properties) programmatically.

The Android framework gives you the flexibility to use either or both of these methods for
declaring and managing your application's UI. For example, you could declare your application's
default layouts in XML, including the screen elements that will appear in them and their
properties. You could then add code in your application that would modify the state of the screen
objects, including those declared in XML, at run time.

You should also try the Hierarchy Viewer tool, for debugging layouts — it reveals layout
property values, draws wireframes with padding/margin indicators, and full rendered views
while you debug on the emulator or device.
The layout opt tool lets you quickly analyze your layouts and hierarchies for inefficiencies or
other problems.

The advantage to declaring your UI in XML is that it enables you to better separate the
presentation of your application from the code that controls its behavior. Your UI descriptions
are external to your application code, which means that you can modify or adapt it without
having to modify your source code and recompile. For example, you can create XML layouts for
different screen orientations, different device screen sizes, and different languages. Additionally,
declaring the layout in XML makes it easier to visualize the structure of your UI, so it's easier to
debug problems. As such, this document focuses on teaching you how to declare your layout in
XML. If you're interested in instantiating View objects at runtime, refer to the ViewGroup and
View class references.

In general, the XML vocabulary for declaring UI elements closely follows the structure and
naming of the classes and methods, where element names correspond to class names and
attribute names correspond to methods. In fact, the correspondence is often so direct that you can
guess what XML attribute corresponds to a class method, or guess what class corresponds to a
given XML element. However, note that not all vocabulary is identical. In some cases, there are
slight naming differences. For example, the EditText element has a text attribute that corresponds
to EditText.setText().

6.3.4 Application Activity

An activity is a single, focused thing that the user can do. Almost all activities interact with the
user, so the Activity class takes care of creating a window for you in which you can place your
UI with setContentView(View). While activities are often presented to the user as full-screen
windows, they can also be used in other ways: as floating windows (via a theme with
windowIsFloating set) or embedded inside of another activity (using ActivityGroup).

There are two methods almost all subclasses of Activity will implement:

onCreate(Bundle) is where you initialize your activity. Most importantly, here you will usually
call setContentView(int) with a layout resource defining your UI, and using findViewById(int)
to retrieve the widgets in that UI that you need to interact with programmatically.
onPause() is where you deal with the user leaving your activity. Most importantly, any changes
made by the user should at this point be committed (usually to the ContentProvider holding the
data).

To be of use with Context.startActivity (), all activity classes must have a corresponding
<activity> declaration in their package's AndroidManifest.xml.
6.3.5 Application SQL Databases

Saving data to a database is ideal for repeating or structured data, such as contact information.
This class assumes that you are familiar with SQL databases in general and helps you get started
with SQLite databases on Android. The APIs you'll need to use a database on Android are
available in the android.database.sqlite package.

6.4 CODE SNIPPETS

 Login

Add Expense

Menu

Send SMS
Chapter 7

SOFTWARE TESTING

7.1 INTRODUCTION

Software testing is a process of executing a program or application with the intent of finding the
software bugs.

Software testing is a critical element of software quality assurance and represents the ultimate
process to ensure the correctness of the product. The quality product always enhances the
customer confidence in using the product thereby increasing the business economics. In other
words, a good quality product means zero defects, which is derived from a better quality process
in testing.

Testing the product means adding value to it by raising the quality or reliability of the product.
Raising the reliability of the product means finding and removing errors. Hence one should not
test a product to show that it works; rather, one should start with the assumption that the program
contains errors and then test the program to find as many of the errors as possible.

The main objective of testing is to find defects in requirements, design, documentation, and code
as early as possible. The test process should be such that the software product that will be
delivered to the customer is defect less. All Tests should be traceable to customer requirements.
Test cases must be written for invalid and unexpected, as well as for valid and expected input
conditions.
A necessary part of a test case is a definition of the expected output or result. A good test case is
one that has high probability of detecting an as-yet undiscovered error.
Manual Testing
Manual testing includes testing a software manually, i.e., without using any automated tool or
any script. In this type, the tester takes over the role of an end-user and tests the software to
identify any unexpected behavior or bug. There are different stages for manual testing such as
unit testing, integration testing, system testing, and user acceptance testing.

Testers use test plans, test cases, or test scenarios to test a software to ensure the completeness of
testing. Manual testing also includes exploratory testing, as testers explore the software to
identify errors in it.

Different stages for manual testing:

Unit Testing
This type of testing is performed by developers before the setup is handed over to the testing
team to formally execute the test cases. Unit testing is performed by the respective developers on
the individual units of source code assigned areas. The developers use test data that is different
from the test data of the quality assurance team.
Tests that are performed during the unit testing in GMS app are explained below:

1) Module Interface test: In module interface test, it is checked whether the information is
properly flowing in to the program unit (or module) and properly happen out of it or not.

E.g. The user registration details should be available from the layout to the corresponding
controller and from the controller it should flow to the model.

2) Boundary conditions: It is observed that much software often fails at boundary related
conditions. That’s why boundary related conditions are always tested to make safe that the
program is properly working at its boundary condition’s.

E.g. In case of if...else if... else... construct all the conditions are checked in the app. In case of
loops, it is checked to see that the loops are not infinite and terminate once the condition
becomes false.

3) Error handling paths: These are tested to review if errors are handled properly.

E.g. 1. Validation during login (Checking for wrong credentials)

2. Validation of password during registration (Password should adhere to password
policy - minimum 8 characters with a number and special character)
3. Validation for Category, Amount, Description when adding expense

Integration Testing
Integration testing is defined as the testing of combined parts of an application to determine if
they function correctly. Integration testing can be done in two ways: Bottom-up integration
testing and Top-down integration testing. In this project we have followed the Bottom-up
integration method.
Here testing begins with unit testing, followed by tests of progressively higher-level
combinations of units called modules or builds.

Once all the different modules were integrated in the app, the app was tested for the following:

1. Transition from one screen to another

2. Data from the layouts is getting saved properly in the database.
3. Data is retrieved properly from the database and displayed in the layouts.
4. SMS and mail are sent properly when user selects this option from menu.
5. Menu items are working properly.
6. Reports are generated with accurate values

System Testing
System testing tests the system as a whole. Once all the components are integrated, the
application as a whole is tested rigorously to see that it meets the specified Quality Standards.

The app was installed on an Android mobile and all the features were tested rigorously for all
possible inputs. Different test cases were executed to see if the app behaved as executed and
there were no crashes and unexpected behavior.
 7.4 TEST CASES

7.4.1 Functional Test Cases

Test Test case Test case Test steps Test

case name description status
ID Step I/p given Expected o/p Actual o/p P/F

To verify
that the
TC0 Login Login with
Valid Login Login Pass
1 User has username successful successful
entered Valid &
username & password
Valid password
username
and
password

To verify
that the
Login User Login with Invalid Login Appropriate Pass
username unsuccessful error
has entered Invalid & message is
username & displayed
Valid password password
username
and
password
 To verify
that the user
TC0 Registration has Enter all the Valid Registered Registered Pass
2 registered valid user details
successfully successfully
by entering details
valid details

To verify If entered Pass

that the user details are
Registration has not valid or Invalid Registration Appropriat
registered some of the details unsuccessful
e error
by entering details are message is
valid details missing displayed

TC0 Add To verify All the Valid Expense is Expense is Pass

3 Expense that the user required details added added
has entered, details are successfully successfully
Category, entered
Amount,
Description
and Date

TC0 Logout In case the Select User is taken User is taken Pass
4 menu user selects Logout to Login to Login
Logout menu option screen screen
menu
option, he
should be
redirected
back to
Login
screen
Chapter 8

ANNEXURE/SCREEN SHOTS

8.1 CONCLUSION

Tracking your expenses daily can save you money, but it can also help you set financial goals for
the future. If you know exactly where your money is going every month, you can easily see
where some cutbacks and compromises can be made. It will also give you a good outlook on
your spending habits and those impulse buys will stick out like little red flags.

8.2 SCREENSHOTS
Chapter 9

BIBLIOGRAPHY

https://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller
https://www.forbes.com/sites/samanthasharf/2016/03/02/12-free-apps-to-track-your-spending-
and-how-to-pick-the-best-one-for-you/
https://play.google.com/store/apps/details?id=com.mhriley.spendingtracker&hl=en
https://developer.android.com
https://developer.android.com/reference/android/telephony/SmsManager.html