Doctors Appointment

1. INTRODUCTION
The above point will describe what is the need to make this system, the problem
description in detail, about the scope of the project.

1.1 Need for the system

Doctors Appointment app is a smart appointment booking application that provides
patients or any user an easy way of booking a doctors appointment online. The task
becomes very tedious for the compounder or doctor himself in manually allotting
appointments for the user as per their availability. Hence this app offers an effective
solution where users can view various booking slots available and select the preferred
date and time. Patient or user can select any doctor from the list provided based on the
disease and can easily cancel the booking anytime.
This application helps to reduce the waiting time of the patient, as his/her
appointment will be booked by him/her. Sometimes the patient has to wait in the queue
for his turn. This drawback of a common appointment system is overcome by Doctors
Appointment App as the patient will arrive at the clinic/hospital at the time of his
appointment and not in advance.
The system will not only allow the users to book appointment for themselves but
for their friends/relatives as well because of its share appointment feature. Therefore,
this application is the most convenient and helpful appointment system.

1.2 Detailed Problem Definition

Under manual appointment system, the patient has to first wait in line to take
appointment for the doctor and wait for his/her time. But due to Doctors Appointment
GIT,Jaipur
1

Doctors Appointment

App, all manual processes have been automated. The patient can book the appointment
on his/ her mobile phone easily without the need to visit the doctors venue. When the
appointment was booked by the common method, the patient has to go to the
clinic/hospital before time if the appointment booked was not sure. So this would
increase the waiting time of the patient as he/she has to wait in a queue for the turn to
come. Therefore, this application helps to reduce the waiting time of the patient. In the
common appointment system, the appointment is mostly booked by not keeping in mind
the preference of the patient. But in this application, the patient can select the date and
time of appointment according to his/her preference.

1.3 Project Scope

Now a days, most people do not have time in their busy life. So if they want to go to a
doctor, they will think twice because the process of booking an appointment and waiting
in the queue is cumbersome and time consuming. In this case, Doctors Appointment App
will come to rescue as one can easily book the appointment for a doctor and need not go
to the clinic/hospital. Therefore, this application has a vast scope as it will reduce the
effort and waiting time of a patient. Sometimes, even to edit/cancel the appointment, the
patient has to either visit the clinic/hospital or has to make a phone call. But by using this
application, the patient can easily edit/cancel the appointment. Therefore, the proposed
system will be needed by most of the people as all their manual efforts will be reduced.

1.4 Presently available systems for the same

Currently, there are number of applications available for booking doctors appointment,
but Doctors Appointment App will be proved the most efficient and the user friendly
application of them all due to its easy-to-understand layout and functioning.

GIT,Jaipur
2

Doctors Appointment

2. GENERAL DESCRIPTION
This point will tell about the outcome of the project, the technology which is used in
making this project and whether the project is feasible or not, that is its feasibility study.

2.1 Project plan

The outcome of the project will be an android application named Doctors Appointment
app which will run on any android device like mobile phone, tablet etc. It is a smart
appointment booking application that will provide patients/users an easy way of booking
a doctors appointment on their mobile devices. This application will allow the
patient/user to search for the desired doctor from the list of doctors provided and book the
appointment time and date according to his/her preference. Patient/user can view various
booking slots available and select the preferred date and time. The already booked space
will be marked red and will not be available for anyone else for the specified time. The
system also allows patient/user to cancel/edit his/her booking anytime.
The patient/user can not only book appointment for himself/herself but also for
his/her relatives or friends as the application provides the feature of share appointment
in which the details of the doctor including doctors name and address along with the date
and time of appointment is shared.

2.2 About Technology

To develop or implement any system, some or the other technology is used. The selection
of the technology is very critical task. The technology must be decided by keeping the
system to be developed in mind. The technology which is used in implementing the
Doctor Appointment App is Android.

GIT,Jaipur
3

Doctors Appointment

2.2.1 Android
Android is a software stack for mobile devices that includes an operating system,
middleware and key applications. Android is a software platform and operating system
for mobile devices based on the Linux operating system and developed by Google and
the Open Handset Alliance. It allows developers to write managed code in a Java-like
language that utilizes Google-developed Java libraries, but does not support programs
developed in native code.
The unveiling of the Android platform on 5 November 2007 was announced with
the founding of the Open Handset Alliance, a consortium of 34 hardware, software and
telecom companies devoted to advancing open standards for mobile devices. When
released in 2008, most of the Android platforms were made available under the Apache
free-software and open-source license.
Android offers a unified approach to application development for mobile devices
which means developers need only develop for Android, and their applications should be
able to run on different devices powered by Android. It has its own virtual machine
known as Dalvik Virtual Machine (DVM), which is used for executing the android
applications.
Androids user interface is mainly based on direct manipulation, using touch
gestures that loosely correspond to real-world actions, such as swiping, tapping and
pinching, to manipulate on-screen objects, along with a virtual keyboard for text input. In
addition to touchscreen devices, Google has further developed Android TV for
televisions, Android auto for cars, and Android Wear for wrist watches, each with a
specialized user interface. Variants of Android are also used on notebooks, game
consoles, digital cameras, and other electronics.

GIT,Jaipur
4

Doctors Appointment

Android has the largest installed base of all operating systems of any kind. Android
has been the best selling OS on tablets since 2013, and on smartphones it is dominant by
any metric. As of July 2013, the Google Play store has had over one million Android
applications ("apps") published including many "business-class apps" that rival
competing mobile platforms and over 50 billion applications downloaded. An April
May 2013 survey of mobile application developers found that 71% of developers create
applications for Android, and a 2015 survey found that 40% of full-time professional
developers see Android as their priority target platform, which is comparable to Apples
IOS on 37% with both platforms far above others. In September 2015, Android had 1.4
billion monthly active users. The success of Android has made it a target for patent (and
copyright) litigation as part of the so-called "smartphone wars" between technology
companies.
.

2.2.2 Features of Android

2.2.2.1 Application Framework
It is used to write applications for Android. Unlike other embedded mobile environments,
Android applications are all equal, for instance, applications which come with the phone
are no different than those that any developer writes. The framework is supported by
numerous open source libraries such as openssl, SQLite and libc. It is also supported by
the Android core libraries. From the point of security, the framework is based on UNIX
file system permissions that assure applications have only those abilities that mobile
phone owner gave them at install time.

2.2.2.2 Dalvik Virtual Machine

The Dalvik Virtual Machine (DVM) is an android virtual machine optimized for mobile
devices. It optimizes the virtual machine for memory, battery life and performance.
Dalvik is a name of a town in Iceland. The Dalvik VM was written by Dan Bornstein.
GIT,Jaipur
5

Doctors Appointment

It is extremely low-memory based virtual machine, which was designed especially

for Android to run on embedded systems and work well in low power situations. It is also
tuned to the COU attributes. The Dalvik Virtual Machine creates a special file format
(.DEX) that is created through build time post processing. The Dex compiler converts the
class files into the .dex file that run on the Dalvik VM. Multiple class files are converted
into one dex file. Conversion between Java classes and .DEX format is done by including
dx tool. The javac tool compiles the java source file into the class file. The dx tool
takes all the class files of your application and generates a single .dex file. It is a
platform-specific tool. The Android Assets Packaging Tool (aapt) handles the packaging
process. DVM is thus an integral part of android, which is typically used on mobile
devices such as mobile phones and tablet computers.

2.2.2.3 Integrated Browser

Google made a right choice on choosing WebKit as open source web browser. They
added a two pass layout and frame flattening. Two pass layout loads a page without
waiting for blocking elements, such as external CSS or external JavaScript and after a
while renders again with all resources downloaded to the device. Frame flattering coverts
founded frames into single one and loads into the browser. These features increase speed
and usability of browsing the internet via mobile phones.

2.2.2.4 SQLite
Extremely small (~500kb) relational database management system, is integrated in
Android. It is based on function calls and single files, where all definitions, tables and
data are stored. This simple design is more than suitable for a platform such as Android.
SQLite is used for structured data storage. It is a powerful and lightweight relational
database engine available to all applications.

GIT,Jaipur
6

Doctors Appointment

2.2.2.5 Handset Layouts

The platform is adaptable to both larger, VGA, 2D graphics library, 3D graphics library
based on OpenGL ES 1.0 specifications, traditional smart phone layouts. An underlying
2D graphics engine is also included. Surface Manager manages access to the display
subsystem and seamlessly composites 2D and 3D graphic layers from multiple
applications.

2.2.2.6 Connectivity and messaging

Android supports a wide variety of connectivity technologies including GSM, CDMA,
Bluetooth, EDGE, EVDO, 3G, Wi-Fi and now 4G also. SMS, MMS, and XMPP are
available forms of messaging including threaded text messaging.

2.2.2.7 Java Virtual Machine (JVM)

Software written in Java can be compiled into Dalvik bytecodes and executed in the
Dalvik Virtual Machine (DVM), which is a specialized VM implementation designed for
mobile device use, although not technically a standard Java Virtual Machine.

2.2.2.8 Media support and additional hardware support

Android supports advanced audio/video/still media formats such as MPEG-4, H.264,
MP3, and AAC, AMR, JPEG, PNG, GIF. It is fully capable of utilizing video/still
cameras, touchscreens, GPS, compasses, accelerometers, and accelerated 3D graphics.

2.2.2.9 Development Environment

Android includes a device emulator, tools for debugging, memory and performance
profiling, a plugin for the Eclipse IDE. There are a number of hardware dependent
GIT,Jaipur
7

Doctors Appointment

features, for instance, a huge media and connection support, GPS, improved support for
camera and simply GSM technology. A great work was done for the developers to start
work with Android using device emulator, tools for debugging and plugin for Eclipse
IDE.

2.2.3 Architecture of Android

The software stack is split into four layers:

The application layer

The application framework
The libraries and runtime
The linux kernel

The following diagram shows the major components of the Android operating system.
Each section is described in more detail below.

GIT,Jaipur
8

Doctors Appointment

Architecture of android

2.2.3.1 Linux Kernel

Android architecture is based on Linux 2.6 kernel with approximately 115 patches. It
provides basic system functionality like memory management,process
management,device management like camera, keypad, display etc., security management,
network stack and other important issues. Kernel handles all the things that Linux is
really good at such networking and a vast array of device drivers, which take the pain out
of interfacing to peripheral hardware. It helps in software or hardware binding for better
communication. This layer is the core of android architecture. Therefore, the user should
bring Linux in his mobile device as the main operating system and install all the drivers
required in order to run it.
GIT,Jaipur
9

Doctors Appointment

2.2.3.2 Libraries and runtime

On the top of Linux Kernel, there is a set of libraries including open-source, web browser
libraries to access web browsers, libraries for audio and video formats etc. Android has its
own libraries, which is written in C/C++. These libraries are responsible for stable
performance of various components.They cannot be accessed directly. With the help of
application framework, we can access these libraries. For data storage, Android uses
SQLite which locates a single file for all operations related to database.
At the same level, there is Android Runtime, where the main component Dalvik
Virtual Machine is located. It was designed specifically for android running in limited
environment, where the limited battery, CPU, memory and data storage are the main
issues. Android gives an integrated tool dx, which converts generated bytecode from
.jar to .dex file, after this the bytecode becomes much more efficient to run on the small
processors. The Android runtime also provides a set of core libraries which enables
Android application developers to write Android applications using standard Java
programming language.

2.2.3.3 Application framework

After that, there is Application Framework, written in Java language. It is a toolkit that all
applications use, ones which come with mobile devices like Contacts or SMS box, or
applications written by Google and any Android developer.
It has several components. The Activity Manager manages the life circle of the
applications and provides a common navigation back stack for applications, which are
running in different processes. The Package Manager keeps track of the applications,
which are installed in the device. The Windows Manager is Java programming language
abstraction on the top of lower level services that are provided by the Surface Manager.
GIT,Jaipur
10

Doctors Appointment

The Telephony Manager contains a set of API necessary for calling applications. Content
Provider was built for Android to share a data with other applications. The Resource
Manager is used to store localized strings, bitmaps, layout file descriptions and other
external parts of the application. The View System generates a set of buttons and lists in
UI.Other components like Notification Manager is used to customize display alerts and
other functions.

2.2.3.4 Application Layer

At the top layer of Android architecture we have all the applications, which are used by
the final user. It includes the home application, the contacts application, the browser, and
apps. All the applications like camera, Google maps, browser, sms, calendars, contacts
are native applications. These applications work with end user with the help of
application framework to operate. By installing different applications, the user can turn
his mobile phones into unique, optimized and smart mobile phone. All applications are
written using the Java programming language.

2.2.4 Versions of Android

The version history of the Android mobile operating system began with the release of the
Android alpha in November 2007. The first commercial version, Android 1.0, was
released in September 2008. Android is continually developed by Google and the Open
Handset Alliance (OHA), and has seen a number of updates to its base operating system
since the initial release.
Versions 1.0 and 1.1 were not released under specific code names, but since April
2009's Android 1.5 "Cupcake", Android versions have had confectionary-themed code
names

GIT,Jaipur
11

Doctors Appointment

Android Versions
Details of versions of Android
Code Name

Version

Initial Release

Number

Date

N/A

1.0

23 September 2008

N/A

1.1

9 February 2009

Cupcake

1.5

27 April 2009

Donut

1.6

15 September 2009

clair

2.0-2.1

26 October 2009

5-7

Froyo

2.1-2.2.3

20 May 2010

Gingerbread

2.3-2.3.7

6 December 2010

9-10

Honeycomb

3.0-3.2.6

22 February 2011

11-13

Ice cream sandwich

4.0-4.0.4

18 October 2011

14-15

Jelly Bean

4.1-4.3.1

9 July 2012

16-18

Kitkat

4.4-4.4.4

31 October 2013

19-20

Lollipop

5.0-5.1.1

12 November 2014

21-22

GIT,Jaipur
12

API Level

Doctors Appointment

Marshmallow

6.0-6.0.1

5 October 2015

23

Nougat

7.0

22 August 2016

24

2.2.5 Advantages of Android

It gives the ability for anyone to customize the Google Android platform.

It gives you better notification.

It lets you choose your hardware.

It has better app market (1,80,000 applications).

A more mature platform.

With the support of many applications, the user can change the screen display.

Supports all Google services from Gmail to Google reader.

With Google chrome, you can open many windows at once.

2.3 Feasibility Study

A feasibility study is carried out to select the best system that meets performance
requirements. The main aim of the feasibility study activity is to determine whether it
would be financially and technically feasible to develop the product. The feasibility study
activity involves the analysis of the problem and collection of all relevant information
relating to the product such as the different data items which would be input to the
system, the processing required to be carried out on these data, the output data required to
be produced by the system as well as various constraints on the behavior of the system.
The purpose of feasibility study is not to solve the problem, but to determine whether the
problem is worth solving. It is an analysis of the viability of an idea through a disciplined
and documented process of thinking through the idea from its logical beginning to its
GIT,Jaipur
13

Doctors Appointment

logical end. It is primary and most important thing in development of a project. The study
serves as a way to prove the projects reasonability and justify the need for launch.
The feasibility study concentrated on the following areas:

Operational feasibility
Technical feasibility
Economic feasibility

2.3.1 Operational Feasibility

Operational feasibility is a measure of how well a proposed system solves the problems,
and takes advantage of the opportunities identified during scope definition and how it
satisfies the requirements identified in the requirements analysis phase of system
development. The study tests the operational scope of the software to be developed. The
proposed software must have high operational feasibility. Operational feasibility is
mainly concerned with issues like whether the system will be used if it is developed and
implemented, whether there will be resistance from users that will affect the possible
application benefits.
Doctors Appointment app has undergone the operational feasibility test that is
mentioned above and has proved its feasibility as it is one of those apps which is needed
by most of the people and will be used by many people in future because of its
functionality and user friendly layout.

2.3.2 Technical feasibility

The technical feasibility study compares the level of technology available in the software
development firm and the level of technology required for the development of the
product. Here the level of technology consists of the programming language, the
hardware resources, other software tools etc. This is concerned with specifying the

GIT,Jaipur
14

Doctors Appointment

equipments and the software to satisfy the user requirements. The technical needs of the
system vary considerably but might include:

The facility to produce outputs in a given time.

Response time under certain conditions.
Ability to process a certain volume of transactions at a specified speed.
Facility to communicate data to a distant location.
Technical feasibility centers on the existing computer system, hardware, software

etc and to what extend it can support the system. In examining the technical feasibility,
the configuration of the system is given more importance than the actual hardware. The
configuration should provide the complete picture of the system requirements.
Technical feasibility stage for the Doctors Appointment App gives the detailed
description about the technology used for the implementation of the application. It
certainly provides the output in a given time as it instantly books the appointment for a
preferred doctor and also provides confirmation. Through this application, the user can
book an appointment for his/her friend/relative and can share the details of appointment
easily. The software is used for the development of this software is Android which is one
of the most easy-to-use and most common software.

2.3.3 Economic feasibility

The economic feasibility study evaluates the cost of the software development against the
ultimate income or benefits from the developed system. There must be scoped for profit
after the successful completion of the project. It is the most frequently used method for
evaluating the effectiveness of a new system. More commonly known as cost/benefit
analysis, the procedure is to determine the benefits and savings that are expected from a
system and compare them with costs. If the benefits outweigh costs, then the decision is
made to design and implement the system.

GIT,Jaipur
15

Doctors Appointment

Doctors Appointment App is economically very feasible as the benefits obtained

from the application are greater than its cost. Also, there is a lot of scope of updating the
system, so it will be very helpful and beneficial for most of the people. And thus, it will
be used among various people and will provide benefits.

3. SWDLC PHASES
A Software Development Life Cycle is an abstract representation of gradual development
and evolution of the software that undergoes a series of sequential or concurrent steps of
the software development process. Each of these steps results in the development of a
software product either a minor or major component of the software system in
contribution to the completion of the system. Each step requires some input and produces
some form of output which further becomes the input of the next step. The process goes
on in stepwise fashion until the software product is developed fully.
The software development life cycle consists of the following steps:

GIT,Jaipur
16

Doctors Appointment

Steps of SWDLC

1. Requirement Analysis
This step is the first and primary step of Software Development Life Cycle which
analysis the requirements of the software. It is performed after the feasibility study has
been done. The requirement term in this concern can be understood as: A condition or
capability needed by a customer to solve a problem and a condition or capability that
must be met by a system. To analyze the requirement, this step is defined as to indentify
and document the exact requirements of the software which can be fulfilled with the
initial step of communication between the customer and the developer. In such
communication, they discuss the real and actual requirements required by the software.
As the result of this step, the Software Requirement Specification SRS is made.

GIT,Jaipur
17

Doctors Appointment

Requirement Analysis phase for Doctors Appointment App was done on the basis
of locality, doctors present in the locality, their experience etc. Hardware and software
requirements were also taken into considerations which are mentioned in 3.2 and 3.3
point respectively. This step must be done very carefully as it is the initial step for the
development of the software and based on this step, all the other steps are implemented.
Keeping these requirements in mind, well further go for the next step of Software
Development Life Cycle, that is, design.
2. Design
With full and complete understanding of the requirement analysis phase, the next step is
designing of the software. Here analysis is made on the design of the system that is going
to be developed. In other words database design, the design of the architecture chosen,
functional specification design, low level design documents, high level design documents
and so on take place. Care must be taken to prepare these design documents because the
next phases namely the development phase is based on these design documents. If a well
structured and analyzed design document is prepared it would reduce the time taken in
the coming steps namely development and testing phases of the software development
life cycle.
This step is divided into level designing. Named as, preliminary design of high
level design and detailed design or low level designs.Preliminary design concerns the
brief overview of the software architecture and structure rather than goes into the details
of the module. This design is refined by designing each module in detail in detailed
design. As the result of this step, it produces the software design specification (SDS).
This step makes the clear distinction between the requirement analysis step and the
design step by using the term what and how. What term, what is the problem included
in the requirement analysis step whereas the how term, how the problem will be
solved out refers to the design step.

GIT,Jaipur
18

Doctors Appointment

The designing phase for doctors Appointment app is done very carefully keeping in
mind all the requirements discussed in requirement analysis phase. Various layouts were
made first, which tells about how the app will look, about its UI, and will give a brief
description about the functionality of the app. The app is divided into different modules
which are discussed in 3.1 point.
3. Coding
Coding is the phase that produces the actual code that will be delivered to the customer as
the operational product. To develop the code a specific programming language is chosen
either through its features or directly specified by the customer. This is the phase where
actual development of the system takes place. That is based on the design documents
prepared in the earlier phase code is written in the programming technology chosen. After
the code is developed generation of code also takes place in this phase. In other words the
code is converted into executables in this phase after code generation.
For the development of Doctors Appointment App, the programming technology which is
used is Android. This technology is very user friendly for the users and therefore it is
mostly used. Android provides various libraries and functionalities due to which a great
look is provided to the app and thus many users use android based mobile devices.
4. Module Level Testing
A software or system which is not tested would be of poor quality. This is because this is
the phase where system developed would be tested and reports are prepared about bugs or
errors in system. To do this testing phase there are different levels and methods of testing
like unit testing, system test and so on. Based on the need the testing methods are chosen
and reports are prepared about bugs. After this process the system again goes to
development phase for correction of errors and again tested. This process continues until
the system is found to be error free. To ease the testing process debuggers or testing tools
are also available. In this phase, individual developed modules are tested here. It is also
called as unit testing. This testing is performed for each of the module separately.
GIT,Jaipur
19

Doctors Appointment

Doctors Appointment App is divided into various modules like login/signup, main screen,
doctor list, book appointment etc. The individual testing of these modules is done
carefully and it is checked that whether the output is obtained at each module or not. If
output is obtained then well move to next module else modify that module to obtain the
correct output.
5. Integration and system testing
All the modules are collected and integrated appropriately with each other. Interface is
provided among them and then the whole system is tested fully. Integration testing is as
much important as the module level testing. The modules which are tested individually in
module level testing are then tested collectively by integrating all the modules and testing
the full developed system.
The modules of the Doctors Appointment app are integrated and then complete
testing of the whole system is performed. The testing is done till the correct output is not
obtained.

6. Delivery, implementation and maintenance

After the testing phase is completely through and the system is found to be error free it is
delivered to the customer. But no real system would be error free even then. This is
because when the system gets executed in real user system scenarios there would be
possibilities of lot of bugs and errors. This phase is called the maintenance phase and the
errors in this are recorded and changes has to be made in the system accordingly and
again testing phase comes into picture.

GIT,Jaipur
20

Doctors Appointment

Once the complete system is tested then that system is delivered to the customer
who will implement it on its organization site. After delivery, any modification or
changes can be made to help in maintenance.

3.1 Modules
A module is a separate unit of software or hardware that can be invoked independently. It
is an independent part of the program. The modules are then integrated to form a
complete system. The project consists of following modules:

3.1.1 Sign Up
In this module if the user is new then he/she will request for signing up a new account
and after that he/she will be directed to Signup Page where the user will enter all the
relevant information. An alert dialog box will be shown if any of the information is not
written. Another alert dialog box will be shown which will confirm from the user to save
the information and signup the account. Then the user will be directed to the login page.

3.1.2 Login
In this module, the user will enter his/her email id and password. The verification of the
email id and password entered will be done based on the values stored in the database
which were saved during the signup phase by the user. If the values are not matched, that
is there is no user saved with the email id and password entered, and then the user will be
informed to signup his/her account.

3.1.3 Main screen

GIT,Jaipur
21

Doctors Appointment

The main screen consists of two sections which are By Field and By Name which are
displayed using swipe tabs. By Field section consists of the various fields through which
the user can select the specific field and then see the doctors list and book appointment
accordingly. While in By Name section the user can directly select the doctor (in case
he/she knows the name already) and book appointment for that doctor.

3.1.4 Doctors List

This module consists of various names of the doctors for a specific speciality with the
information of their experience and address. The user will have the choice to book the
appointment for any of the doctor by clicking on the Book Appointment button.

3.1.5 Book Appointment

Book Appointment module consists of the calendar and various time slots. From
calendar, the user can select any preferred date. While from the time slots, the user can
select any desired time (if not already booked) and can confirm the appointment by
clicking on Confirm Appointment button. The already booked slots will be displayed in
red and the user will not be allowed to select that slot. An alert dialog box will pop up to
confirm from the user to book the appointment. When the user will on yes, a toast
(notification for short period of time) will be displayed which will notify that the
Appointment is booked.

3.1.6 Option Menu

An option menu is shown on the top right corner of the screen of the app which consists
of four options, namely, My Profile, My Appointment, Logout and Exit. My Profile and
My Appointment will be discussed below. Logout will logout the current account of the

GIT,Jaipur
22

Doctors Appointment

user and will direct him/her to the login screen. Exit will direct the user out of the app
and the home page of the mobile device will be shown.

3.1.7 My Profile
This module will display all the details of the user which were saved by him/her during
signup module. In this module the user can edit particular information and also delete
his/her account.

3.1.5 My Appointment
This module will provide the list of all the appointments booked by the user and will
consists of the doctors name and address, and also the time and date of the appointment.
There is a context menu for each appointment which will be displayed on long press and
the menu will contain three options, namely, Edit appointment, Delete appointment and
Share appointment. By Edit and delete appointment, the user can edit and delete the
appointment for the specified doctor respectively. Share appointment, as the name
suggest, will allow the user to share the details of the appointment to any friend or
relative by using any of the sharing medium present in the mobile device (like Bluetooth,
mail, etc).

3.2 Hardware Requirements

One of the best parts for the development of an Android app is that minimal hardware is
required for the applications to run. Doctor Appointment App does not have any major
hardware requirement except for an Android mobile or tablet with Android 4.0 (Jelly
Bean) or above.

GIT,Jaipur
23

Doctors Appointment

3.3 Software Requirements

Doctors Appointment App requires only two softwares for its development, they are,
Android Studio and Genymotion. Let us discuss them in detail:

3.3.1 Android Studio

Android Studio is an integrated development environment (IDE) released by Google
during the Google I/O developers event last May 2013. This brand new IDE is made
exclusively for Android development and is intended to be an alternative support for
application creation. The most recent release, version 0.4.2, is capable of supporting
designing, testing, and debugging. Android Studio provides the fastest tools for building
apps on every type of Android device. World-class code editing, debugging, performance
tooling, a flexible build system, and an instant build/deploy system all allow you to focus
on building unique and high quality apps.
With Android Studio you can write better code, work faster, and be more
productive with an intelligent code editor that helps you each step of the way. Android
Studio is built on IntelliJ and is capable of advanced code completion, refactoring, and
code analysis. It also consists of a fast and feature-rich emulator through which you can
install and run your apps faster than with a physical device and test your app on virtually
any Android device configuration like Android phones, Android tablets, Android Wear,
and Android TV devices. The new Android Emulator 2.0 is faster than ever and allows
you to dynamically resize the emulator and access a suite of sensor controls.
Android Studio contains a robust and flexible build system through which you can
easily configure your project to include code libraries and generate multiple build
variants from a single project. With Gradle, Android Studio offers high-performance
build automation, robust dependency management, and customizable build
configurations. It also consists of various code templates and GitHub integration by
GIT,Jaipur
24

Doctors Appointment

which you can start projects with code templates for patterns such as navigation drawer
and view pagers, or import Google code samples from GitHub. Android Studio's project
wizards make it easier than ever to add code in a new project.
It consists of various features:

A flexible Gradle-based build system

A fast and feature-rich emulator

A unified environment where you can develop for all Android devices

Instant Run to push changes to your running app without building a new APK

Code templates and GitHub integration to help you build common app features
and import sample code

Extensive testing tools and frameworks

Lint tools to catch performance, usability, version compatibility, and other

problems

C++ and NDK support

Built-in support for Google Cloud Platform, making it easy to integrate Google
Cloud Messaging and App Engine
Each project in Android Studio contains one or more modules with source code

files and resource files. Types of modules include: Android app modules, Library
modules, Google app engine modules.

3.3.2 Genymotion

GIT,Jaipur
25

Doctors Appointment

Genymotion is an Android emulator that lets you create virtual replicas of Android
systems and run them on your Windows computer. This handy tool lets you emulate a
large number of Android devices and control simulated sensors like battery, GPS, and
accelerometer. Therefore, testing Android applications will be both easy and effective, as
comprehensive tests can be performed on a large amount of different emulated Android
devices and in many different conditions. In other words, testing an app on all the main
devices available on the market is very easy and affordable when using Genymotion.
Genymotion is remarkably easy to use. The intuitive and straightforward interface
makes creating virtual Android devices and running them a very simple job that can be
performed with ease even by beginners without any problem. Installing it is also a simple
matter. It can also be integrated with Eclipse and Android Studio platforms. The
Genymotion emulator has over 3,000 Android configurations to choose from. Developing
and testing the best app for the myriad devices out there is now possible and simpler than
ever before. Its cheaper and faster too.
Thus, Genymotion is a really handy and powerful Android device emulator that lets
you simulate a large variety of virtual Android devices and offers a really effective and
convenient manner of testing Android apps.

4. SYSTEM DESIGN

GIT,Jaipur
26

Doctors Appointment

System design is the process of defining the architecture, components, modules,

interfaces and data for a system to satisfy specified requirements. It describes the system
requirements, operating environment, system and subsystem architecture, files and
database design, input formats, output layouts, human-machine interfaces, detailed
design, processing logic, and external interfaces. System design is a process through
which requirements are translated into a representation of software.

4.1 Module Design

Module Design, or modularity in design, is a design approach that subdivides a system
into smaller parts called modules or skids, which can be independently created and then
used in different systems. A modular system can be characterized by functional
partitioning into discrete scalable, reusable modules, rigorous use of well-defined
modular interfaces, and making use of industry standards for interfaces. Besides
reduction in cost (due to less customization, and shorter learning time), and flexibility in
design, modularity offers other benefits such as augmentation (adding new solution by
merely plugging in a new module), and exclusion.
Doctors Appointment App is divided into various modules and different tools or
building blocks are required to design these modules. The designing of these modules is
described in detail:

4.1.1 Login and Signup module

This module is designed with the help of different designing tools like TextView (to
display some text), EditText (to allow user to fill information), MarginTop (to get margin
from top), and Button etc. If any details are not filled, then an Alert Dialog Bok is
displayed which says Enter Valid Details. And another Alert Dialog Bok is used to
confirm the details before saving.

GIT,Jaipur
27

Doctors Appointment

4.1.2 Main Screen

To design main screen, swipe tabs are used. Swipe tabs divides the activity into fragments
(small type of activity), and the user can move from one fragment to another either by
swiping or by tabbing. In the By Field fragment, FloatingActionButtons are used to
display the images in similar size and below every FloatingActionButton, a TextView is
used. In By Name fragment, ListView is used which is used to show the name of the
doctors in list form. When any of the name is clicked, it directs the user to the next
module that is to book an appointment.

4.1.3 Doctors List

This module is designed using ListView in which each node consists of the name,
experience and address of the doctor. The node also consists of a button named Book
Appointment which directs the user to book the appointment for the preferred doctor.

4.1.4 Book Appointment

This module consists of a ScrollView due to which the user can scroll down the screen, a
CalendarView which is used to select any date for the appointment and the buttons which
determine the time slots. The user can select any of the preferred time slots. The already
booked slots are shown in red and the user will not be allowed to select that time slot as it
will be unclickable.
One more button is located at the bottom, named Confirm Appointment. When
the user clicks on this button, an Alert Dialog Box is displayed asking for confirmation to
book the appointment. When the appointment is confirmed, a notification for a small
amount of time is displayed which notifies Appointment is booked. This notification is
displayed using Toast which is used to show notification for short amount of time.

GIT,Jaipur
28

Doctors Appointment

4.1.5 Option Menu

Menus are a common user interface component in many types of application. To provide
a familiar and consistent user experience, one should use the Menu. The Option Menu is
the primary collection of menu items for an activity. Its where you should place actions
that have a global impact on the app. Here, in this app, an option menu is created which
consists of four options, namely, My Profile, My Appointment, Logout and Exit. My
Profile will direct the user to his/her profile page. While My Appointment page will direct
him/her to the list of the appointments that were booked by him/her. Logout will logout
the current account of the user and will direct him/her to the login screen. Exit will direct
the user out of the app and the home page of the mobile device will be shown.

4.1.6 My Profile
This module is designed by using TextView, which displays the name, email id, age and
gender of the user. With each information, there is an ImageButton which will allow the
user to edit the specified information which is done using AlertDialogBox. A button for
Delete Account is also created in this module.

4.1.7 My Appointment
This module is designed using ListView where each node consists of the details of the
doctor booked, that is his/her name and address. The node also consists of the date and
the time of appointment that was booked by the user. Context Menu is also created which
consists of three options: Edit Appointment, Delete Appointment and Share Appointment.

4.2. Data Flow Diagram

A Data Flow Diagram (DFD) illustrates how data is processed by as system in terms of
inputs and outputs. As its name indicates its focus is on the flow of information, where
GIT,Jaipur
29

Doctors Appointment

data comes from, where it goes and how it gets stored. A DFD is a graphical
representation of the flow of data through an information system, modeling its process
aspects. A DFD is often used as a preliminary step to create an overview of the system,
which can later be elaborated. DFDs can also be used for the visualization of data
processing (structured design). A DFD shows what kind of information will be input to
and output from the system, where the data will come from and go to, and where the data
will be stored. It does not show information about the timing of process or information
about whether processes will operate in sequence or in parallel. Data flow diagrams are
also known as bubble charts. DFD is a designing tool used in the top-down approach to
System Design. The DFD enables the software engineer to develop models of the
information domain & functional domain at the same time.

4.2.1 DFD Level-0

A context diagram is a top level (also known as "Level 0") data flow diagram. It only
contains one process node ("Process 0") that generalizes the function of the entire system
in relationship to external entities.

GIT,Jaipur
30

Doctors Appointment

DFD Level-0

4.2.2 DFD Level-1

The Level 1 DFD shows how the system is divided into sub-systems (processes), each of
which deals with one or more of the data flows to or from an external agent, and which
together provide all of the functionality of the system as a whole.

DFD Level-1

4.2.3 DFD Level-2

Level-2 DFD focuses more in detail than level-0 and level-1. Here, database is included
for describing the internal functionality clearly. In Doctors appointment app, three
database are used, namely, User database, doctor database and appointment database.
GIT,Jaipur
31

Doctors Appointment

DFD Level-2

4.3 UML Diagram

The Unified Modeling Language (UML) is a general-purpose, developmental, modeling
language that is intended to provide a standard way to visualize the design of a system.
UML was originally motivated by the desire to standardize the disparate notational
systems and approaches to software design developed by Grady Booch, Ivar Jacobson
and James Rambaugh at Rational Software in 199495, with further development led by
them through 1996. The goal from this is to produce a model of the entities involved in
the project which later need to be built. There are various kinds of UML diagrams. They
are as follows:
GIT,Jaipur
32

Doctors Appointment

Use case diagram

Class diagram
Sequence diagram
Collaboration diagram
Activity diagram
Object diagram
Component diagram
Deployment diagram

4.3.1 Use case diagram

Use case diagram for Doctors Appointment App

GIT,Jaipur
33

Doctors Appointment

Use case diagrams are a set of use cases, actors and their relationships. They represent the
use case view of a system. A use case represents a particular functionality of a system. So
use case diagram is used to describe the relationships among the functionalities and their
internal/external controllers. These controllers are known as actors.

4.3.2 Class Diagram

Class Diagram for Doctors Appointment App

The class diagram is a static diagram. It represents the static view of an application. Class
diagram is not only used for visualizing, describing and documenting different aspects of
a system but also for constructing executable code of the software application.

GIT,Jaipur
34

Doctors Appointment

The class diagram describes the attributes and operations of a class and also the
constraints imposed on the system. The class diagrams are widely used in the modeling of
object oriented systems because they are the only UML diagrams which can be mapped
directly with object oriented languages. The class diagram shows a collection of classes,
interfaces, associations, collaborations and constraints. It is also known as a structural
diagram.

4.3.3 Sequence Diagram

Sequence diagram for Doctors Appointment App

GIT,Jaipur
35

Doctors Appointment

4.4 Database design

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. One of the main
principles of SQL databases is the schema: a formal declaration of how the database is
organized. The schema is reflected in the SQL statements that you use to create your
database. You may find it helpful to create a companion class, known as a contract class,
which explicitly specifies the layout of your schema in a systematic and self-documenting
way.
In Doctors Appointment App, there are three tables created in a database. The tables are
for User details, Doctor details and appointment details. The tables with their fields,
datatypes and keys are shown below:
Table for User details
Fields
Id
Name
Age
Gender
Email
Password

Datatypes
Integer
Text
Integer
Text
Text
Text

Key
Primary key
Not null
Not null
Not null
Not null
Not null

Table for Doctor details

Fields
Id
Name
Specialty
Experience
Address

GIT,Jaipur
36

Datatypes
Integer
Text
Integer
Text
Text

Key
Primary key
Not null
Not null
Not null
Not null

Doctors Appointment

Table for Appointment details

Fields
Id
Patient_id
Date
Doctor_name
Docotr_Address
Time

GIT,Jaipur
37

Datatypes
Integer
Text
Text
Text
Text
Text

Key
Primary key
Foreign key
Not null
Foreign key
Not null
Not null

Doctors Appointment

5. CODING
Android follows general Java coding conventions with some additional rules which are
mentioned below:

5.1 Dont ignore exception

It can be tempting to write code that completely ignores an exception. Do not do this.
While you may think your code will never encounter this error condition or that it is not
important to handle it, ignoring exceptions as above creates mines in your code for
someone else to trigger some day. You must handle every Exception in your code in a
principled way; the specific handling varies depending on the case.
Acceptable alternatives (in order of preference) are:

Throw the exception up to the caller of your method.

Throw a new exception that's appropriate to your level of abstraction.

Handle the error gracefully and substitute an appropriate value in the catch {}
block.

Catch the Exception and throw a new RuntimeException. This is dangerous, so do

it only if you are positive that if this error occurs the appropriate thing to do is
crash.

As a last resort, if you are confident that ignoring the exception is appropriate
then you may ignore it, but you must also comment why with a good reason.

5.2 Dont catch generic exception

GIT,Jaipur
38

Doctors Appointment

In almost all cases it is inappropriate to catch generic Exception or Throwable (preferably

not Throwable because it includes Error exceptions). It is very dangerous because it
means that Exceptions you never expected (including RuntimeExceptions like
ClassCastException) get caught in application-level error handling. It obscures the failure
handling properties of your code, meaning if someone adds a new type of Exception in
the code you're calling, the compiler won't help you realize you need to handle the error
differently. In most cases you shouldn't be handling different types of exception the same
way.
The rare exception to this rule is test code and top-level code where you want to
catch all kinds of errors (to prevent them from showing up in a UI, or to keep a batch job
running). In these cases you may catch generic Exception (or Throwable) and handle the
error appropriately. Think very carefully before doing this, though, and put in comments
explaining why it is safe in this place.
Alternatives to catching generic Exception:

Catch each exception separately as separate catch blocks after a single try. This
can be awkward but is still preferable to catching all Exceptions. Beware

repeating too much code in the catch blocks.

Refactor your code to have more fine-grained error handling, with multiple try

blocks. Split up the IO from the parsing, handle errors separately in each case.
Rethrow the exception. Many times you don't need to catch the exception at this
level anyway, just let the method throw it.
Remember: exceptions are your friend! When the compiler complains you're not

catching an exception, don't scowl. Smile: the compiler just made it easier for you to
catch runtime problems in your code.

5.3 Dont use finalizers

GIT,Jaipur
39

Doctors Appointment

Finalizers are a way to have a chunk of code executed when an object is garbage
collected. While they can be handy for doing cleanup (particularly of external resources),
there are no guarantees as to when a finalizer will be called (or even that it will be called
at all). Android doesn't use finalizers. In most cases, you can do what you need from a
finalizer with good exception handling. If you absolutely need it, define a close() method
(or the like) and document exactly when that method needs to be called (see InputStream
for an example). In this case it is appropriate but not required to print a short log message
from the finalizer, as long as it is not expected to flood the logs.

GIT,Jaipur
40

Doctors Appointment

6. SCREEN SHOTS
Based on the modules discussed in the 3.1 and 4.1 step of the report, the respective
screenshots are as follows:

6.1 Splash screen

Splash Screen

6.2 Login screen

GIT,Jaipur
41

Doctors Appointment

Login screen

6.3 Signup screen

Signup screen

GIT,Jaipur
42

Doctors Appointment

Signup screen with alert

Signup with confirmation

GIT,Jaipur
43

Doctors Appointment

6.4 Main screen

By Field section of main screen

By Name section of main screen

GIT,Jaipur
44

Doctors Appointment

6.5 Doctors list

Doctors list

GIT,Jaipur
45

Doctors Appointment

6.6 Book Appointment

Book Appointment screen

GIT,Jaipur
46

Doctors Appointment

Color change during selection

Alert dialog box for confirmation

GIT,Jaipur
47

Doctors Appointment

Toast (short notification)

Color difference for already booked slot

GIT,Jaipur
48

Doctors Appointment

6.7 Option Menu

Option Menu

6.8 My Appointment

List of appointment
GIT,Jaipur
49

Doctors Appointment

Context Menu

Share Appointment

GIT,Jaipur
50

Doctors Appointment

6.9 My Profile

Profile of user

Edit profile

GIT,Jaipur
51

Doctors Appointment

Delete Account

GIT,Jaipur
52

Doctors Appointment

7. TESTING
Testing your app is an integral part of the app development process. Testing allows you to
verify the correctness, functional behavior, and usability of your app before it is released
publicly. Android tests are based on Junit, and you can run them either as local unit tests
on the JVM or as instrumented tests on an Android device. The Android framework
includes an integrated testing framework that helps you test all aspects of your
application and the SDK tools include tools for setting up and running test applications.
Android's build and test tools assume that test projects are organized into a standard
structure of tests, test case classes, test packages, and test projects.
For each module in a project, Android Studio includes both source sets,
corresponding to the following test types:
Local unit tests
Located at module-name/src/test/java/. These tests run on the local JVM and do not have
access to functional Android framework APIs.
Instrumented tests
Located at module-name/src/androidTest/java/. These are all tests that must run on an
Android hardware device or an Android emulator. Instrumented tests are built into an
APK that runs on the device alongside your app under test. The system runs your test
APK and your app under tests in the same process, so your tests can invoke methods and
modify fields in the app, and automate user interaction with your app.
There are many tools that can be used for testing android applications. Some are
official like Junit, Monkey and some are third party tools that can be used to test android
applications. Fr Doctors appointment app. Junit testing is performed. One can use the
JUnit TestCase class to do unit testing on a class that doesn't call Android APIs. TestCase
is also the base class for AndroidTestCase, which one can use to test Android-dependent
objects. Besides providing the JUnit framework, AndroidTestCase offers Androidspecific setup, teardown, and helper methods.
GIT,Jaipur
53

Doctors Appointment

8. IMPLEMENTATION
Various building blocks are required to build an android application and implement it.
These building blocks provide different kinds of functionality. Some of the building
blocks which were used in implementation of Doctors Appointment App are:

8.1 Activity
It is an user interface component, which corresponds to one screen at a time. It means that
to display Doctors List in the Doctors Appointment Application when any speciality is
chosen, one activity component is used for displaying more detailed information about
the doctors in the form of list.

8.2 Intent Receiver

It wakes up a predefined action through external event. For example, to go from one
activity to another, Intent is used. And for Share appointment feature, ShareIntent is
used.

8.3 Service
A task, which is done in the background, is known as service. It means that the user can
start an application from the activity window and keep the service work, while browsing
other applications. For instance, one can browse Google maps application while holding a
call or listening music while browsing other applications.

8.4 Content Providers

GIT,Jaipur
54

Doctors Appointment

A component which allows sharing some of the data with other processes and
applications is known as content provider. It is the best way to communicate the
applications between each other. Android will ship with a set of core application
including email client, SMS program, calendar, maps, browser, contacts, and others.

8.5 Shared Preferences

Shared preferences are used to store any value in the key, value format. For instance,
id of the patient is stored in shared preferences using key as patient_id and its value
will be of that patient which has logged in the account in his/her mobile device. Thus, the
application will store the information regarding to that pateitnd_id only.

GIT,Jaipur
55

Doctors Appointment

9. LIMITATIONS AND SCOPE

Every system consists of any or the other limitations as well as some of the future scope.
Our application is no exception.
There are some limitations in Doctors Appointment app, like:

It requires internet connection.

It requires huge database.

Any application with no future scope is not that useful. The application must be updated
time to time and some feature must be added with every updation. Some of the future
scopes of our application are:

The option of Map can be added, which will allow users to navigate themselves

to the doctors clinic/hospital through map.

Notification/Reminder option can also be added which will remind users of their

appointment.
More number of doctors can be added.
Chatting system between doctor and patient can be added.

GIT,Jaipur
56

Doctors Appointment

10. CONCLUSION
The outcome of this project is a smart android application which will allow users to book
their appointment for preferred doctor on their preferred date and time. This application
will reduce the waiting time of the users as they do not have to wait in queue. It will
increase the easiness of the user. The user can not only book appointment for
himself/herself, but for his/her friend/relative too.
Therefore, the making of such an application will prove to be very helpful to those who
are very busy in their life.

GIT,Jaipur
57

Doctors Appointment

11. REFRENCES

Wikipedia.org
https://www.tutorialspoint.com/
https://www.androiddevelopers.com/
https://www.slideshare.com/
https://www.scribd.com/
https://www.sitepoint.com/

GIT,Jaipur
58

Doctors Appointment

GIT,Jaipur
59

Doctors Appointment

GIT,Jaipur
60

Doctors Appointment

GIT,Jaipur
61

Doctors Appointment

GIT,Jaipur
62

Doctors Appointment

GIT,Jaipur
63