PURPOSE OF THIS PROJECT: This project is mainly used to decrease the time constrain to find all fun and food zones near to the user location.The main advantage of this application is the user can view all the fun and food zones at one place,now we have so many websites and applications which gives information only about food or fun individually.To overcome this disadvantage we developed an application which gives all the details about both fun and food zones based on user specified location so we Entitled this project as ‘FUN AND FOOD’ it is used to provide all fun and food zones near to location specified by the user.The user can view minimum details of nearest fun and food zones and user can also view the details of respective fun and food service provider.

1. 1. INTRODUCTION
PURPOSE OF THIS PROJECT:
This project is mainly used to decrease the time constrain to find all
fun and food zones near to the user location.The main advantage of this application is
the user can view all the fun and food zones at one place,now we have so many
websites and applications which gives information only about food or fun
individually.To overcome this disadvantage we developed an application which gives
all the details about both fun and food zones based on user specified location so we
Entitled this project as ‘FUN AND FOOD’ it is used to provide all fun and food
zones near to location specified by the user.The user can view minimum details of
nearest fun and food zones and user can also view the details of respective fun and
food service provider.
Scope of this Project:
The scope of this project is we can find all the fun and food zones
accurately in specified location and we can also get the details of respective fun
and food service provider.
Overview:
The main aim of this project is to provide all fun and food zones near to location
specified by the user.The user can view the minimum details of nearest fun and food
zones and user can also view the details of respective fun and food service provider.
In this application first we have two fields i,e., fun or food provider and customer by
using fun or food provider field we can do registration and after completion of
registration we can add n number of services to our database so that these services can
be viewed by customer.
.
1

2. 2. LITERATURE SURVEY
2.1. EXSISTING SYSTEM :
The existing system is not providing any fun and food servicess or discounts
to user . User has to go the shop or service provider to know the all the fun and food
servicess and details so it is problem to end user to reach there and to enquire it.
2.2PROPOSED SYSTEM:
The development of this new system objective is to provide the solution to the
problems of existing system. By using this new system, we can fully automate the
entire process of the current system. The new system would like to make as mobile-
enabled so that the information can be shared between the members at any time using
the respective credentials. To track the status of an individual process, the status
update can be centralized using the new system. Being android-enabled system, the
process can be accessed across the world over offline.
.
2

3. 3. REQUIRIMENT ANALYSIS
3.1 Hardware Specification:
• Intel Pentium or More
• 4 GB Ram
• PC with 20GB
3.2 Software Specification:
• WINDOWS OS
• Coding Language: Java 8.0
• ToolKit : Android Studio
• Database: SQLite
3.3 Feasibility study:
The feasibility of the project is analyzed in this phase and business proposal is
put forth with a very general plan for the project and some cost estimates. During
system analysis the feasibility study of the proposed system is to be carried out. This
is to ensure that the proposed system is not a burden to the company. For feasibility
analysis, some understanding of the major requirements for the system is essential.
Three key considerations involved in the feasibility analysis are
 ECONOMICAL FEASIBILITY
 TECHNICAL FEASIBILITY
3

4.  SOCIAL FEASIBILITY
ECONOMICAL FEASIBILITY
This study is carried out to check the economic impact
that the system will have on the organization. The amount of fund
that the company can pour into the research and development of
the system is limited. The expenditures must be justified. Thus the
developed system as well within the budget and this was achieved
because most of the technologies used are freely available. Only
the customized products had to be purchased.
TECHNICAL FEASIBILITY
This study is carried out to check the technical feasibility, that is, the
technical requirements of the system. Any system developed must not
have a high demand on the available technical resources. This will lead
to high demands on the available technical resources. This will lead to
high demands being placed on the client. The developed system must
have a modest requirement, as only minimal or null changes are
required for implementing this system.
SOCIAL FEASIBILITY
The aspect of study is to check the level of acceptance of the
4

5. system by the user. This includes the process of training the user
to use the system efficiently. The user must not feel threatened by
the system, instead must accept it as a necessity. The level of
acceptance by the users solely depends on the methods that are
employed to educate the user about the system and to make him
familiar with it.
4. IMPLEMENTATION
4.1Problem Definition:
By using this application the time constraint taken by the user to
search all fun and food can be reduced i.e., by providing all fun and food
zones at one place.
4.2 Modules Description:
After careful analysis the system has been identified to have the following
modules:
1. Administrator Module:
• Service Provider can register himself directly
• Service Provider can add his service
2. User Module
• User can search the fun and food zones by entering location
• User can communicate with Service Provider
5

6. 4.3 SYSTEM ARCHITECTURE
Software Environment
Android is a Linux-based operating system for mobile devices such as smartphones and
tablet computers. It is developed by the Open Handset Alliance led by Google . Android has a
large community of developers writing applications ("apps") that extend the functionality of
the devices. Developers write primarily in a customized version of Java.
Android architecture
Android consists of a kernel based on the Linux kernel, with middleware,
libraries and APIs written in C and application software running on an
application framework which includes Java-compatible libraries based on
Apache Harmony. Android uses the Dalvik virtual machine with just-in-time
compilation to run Dalvik dex-code (Dalvik Executable), which is usually
translated from Java bytecode.
The main hardware platform for Android is the ARM architecture. There is
support for x86 from the Android x86 project, and Google TV uses a special
x86 version of Android.
6

7. Linux kernel
At the bottom of the layers is Linux - Linux 3.6 with approximately 115 patches.
This provides a level of abstraction between the device hardware and it contains all
the essential hardware drivers like camera, keypad, display etc. Also, the kernel
handles all the things that Linux is really good at such as networking and a vast array
of device drivers, which take the pain out of interfacing to peripheral hardware.
Libraries
On top of Linux kernel there is a set of libraries including open-source Web browser
engine Web Kit, 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.
Android Libraries
This category encompasses those Java-based libraries that are specific to Android development.
Examples of libraries in this category include the application framework libraries in addition to those
that facilitate user interface building, graphics drawing and database access. A summary of some key
core Android libraries available to the Android developer is as follows −
android.app − Provides access to the application model and is the
cornerstone of all Android applications.
android. Content − Facilitates content access, publishing and messaging
7

8. between applications and application components.
android. database − Used to access data published by content providers and
includes SQLite database management classes.
android.opengl − A Java interface to the OpenGL ES 3D graphics rendering
API.
android.os − Provides applications with access to standard operating system
services including messages, system services and inter-process
communication.
Android. Text − Used to render and manipulate text on a device display.
Android. View − the fundamental building blocks of application user
interfaces.
Android. Widget − A rich collection of pre-built user interface components
such as buttons, labels, list views, layout managers, radio buttons etc.
android.webkit − A set of classes intended to allow web-browsing
capabilities to be built into applications.
Having covered the Java-based core libraries in the Android runtime, it is now time
to turn our attention to the C/C++ based libraries contained in this layer of the
Android software stack.
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.
Application Framework
The Application Framework layer provides many higher-level services to
8

9. applications in the form of Java classes. Application developers are allowed to make
use of these services in their applications.
The Android framework includes the following key services −
Activity Manager − Controls all aspects of the application lifecycle and
activity stack.
Content Providers − Allows applications to publish and share data with
other applications.
Resource Manager − Provides access to non-code embedded resources such
as strings, color settings and user interface layouts.
Notifications Manager − Allows applications to display alerts and
notifications to the user.
View System − An extensible set of views used to create application user
interfaces.
Applications
You will find all the Android application at the top layer. You will write your
application to be installed on this layer only. Examples of such applications are
Contacts Books, Browser, and Games etc.
4.3 DESIGN OF DATA FLOW DIAGRAMS
The design phase emphasizes on the transformation of customer requirements as
defined in the SRS document, into a form that is suitable for coding.
The design phase can be broadly classified in two levels. ˆ
Preliminary or high level design
Detailed design
The preliminary design can be further divided into two sub categories
Function Oriented Software Design ˆ
Object Oriented Software Design
4.3.1 Function Oriented Software Design
This design model can be represented by drawing the DFDs (Data Flow Diagrams)
for the given SRS document. A data flow diagram is a graphical representation of the
data flow through an information system which is used to model the process aspects
of the system. DFD is the preliminary step used to create an overview of the system.
DFD is used for structured design.
9

10. Context diagram
A context diagram is a structured graphical tool used for identifying the functional
areas and the processes which are performed within and between the system and
outside the system. Context diagram supports a data-oriented approach for designing
system. It helps in investigating the output and the process requirement of the system.
It helps in defining the boundaries of the proposed system. The symbols used in the
context diagrams are for external entities, data storage and data flows and process.
Here in the following context diagram 4.3.1, we represent our attendance system
which has one external entity i.e. user of the system namely Faculty and the data
flowing in and out of the system is the attendance details.
Fig 4.3.1 Context diagram
The context-level DFD is then exploded to produce a Level 1 DFD which models the
details of the system. The Level 1 DFD shows how the system is divided into sub-
systems (processes), and how each processes deals with one or more of the data flows
to or from an external entity, and how the processes together provide all of the
functionality of the system. The level 1 DFD also identifies the internal data stores
which must be there for the system to do its job, and shows the data flow between the
various parts of the system.
In the below Level 1 DFD dig, the attendance system has been decomposed
further into 5 processes which are namely Login, View courses taken, View enrolled
student list, View attendance, Upload attendance. Each process is accessed by the
Faculty and there is data storage namely Server database, Enrolled student list, Course
list and User details which are used in the system.
------------------------------------------------------------------------------------------------------
Android's kernel is based on the Linux kernel and has further architecture
changes by Google outside the typical Linux kernel development cycle.
Android does not have a native X Window System nor does it support the full
set of standard GNU libraries, and this makes it difficult to port existing Linux
applications or libraries to Android.
Certain features that Google contributed back to the Linux kernel, notably a
power management feature called wakelocks, were rejected by mainline
10

11. kernel developers, partly because kernel maintainers felt that Google did not
show any intent to maintain their own code. Even though Google announced
in April 2010 that they would hire two employees to work with the Linux kernel
community, Greg Kroah-Hartman, the current Linux kernel maintainer for the
-stable branch, said in December 2010 that he was concerned that Google
was no longer trying to get their code changes included in mainstream Linux.
Some Google Android developers hinted that "the Android team was getting
fed up with the process", because they were a small team and had more
urgent work to do on Android.
However, in September 2010, Linux kernel developer Rafael J. Wysocki
added a patch that improved the mainline Linux wakeup events framework.
He said that Android device drivers that use wakelocks can now be easily
merged into mainline Linux, but that Android's opportunistic suspend features
should not be included in the mainline kernel. In 2011 Linus Torvalds said that
"eventually Android and Linux would come back to a common kernel, but it
will probably not be for four to five years".
In December 2011, Greg Kroah-Hartman announced the start of the Android
Mainlining Project, which aims to put some Android drivers, patches and
features back into the Linux kernel, starting in Linux 3.3. further integration
being expected for Linux Kernel 3.4.
Application Framework
By providing an open development platform, Android offers developers the ability to build
extremely rich and innovative applications. Developers are free to take advantage of the
device hardware, access location information, run background services, set alarms, add
notifications to the status bar, and much, much more.
Developers have full access to the same framework APIs used by the core applications. The
application architecture is designed to simplify the reuse of components; any application can
publish its capabilities and any other application may then make use of those capabilities
(subject to security constraints enforced by the framework). This same mechanism allows
11

12. components to be replaced by the user.
Underlying all applications is a set of services and systems, including:
• A rich and extensible set of Views that can be used to build an application, including
lists, grids, text boxes, buttons, and even an embeddable web browser
• Content Providers that enable applications to access data from other applications
(such as Contacts), or to share their own data
• A Resource Manager, providing access to non-code resources such as localized
strings, graphics, and layout files
• A Notification Manager that enables all applications to display custom alerts in the
status bar
• An Activity Manager that manages the lifecycle of applications and provides a
common navigation backstack
Libraries
Android includes a set of C/C++ libraries used by various components of the Android system.
These capabilities are exposed to developers through the Android application framework.
Some of the core libraries are listed below:
• System C library - a BSD-derived implementation of the standard C system library
(libc), tuned for embedded Linux-based devices
• Media Libraries - based on PacketVideo's OpenCORE; the libraries support playback
and recording of many popular audio and video formats, as well as static image files,
including MPEG4, H.264, MP3, AAC, AMR, JPG, and PNG
• Surface Manager - manages access to the display subsystem and seamlessly
composites 2D and 3D graphic layers from multiple applications
• LibWebCore - a modern web browser engine which powers both the Android
browser and an embeddable web view
• SGL - the underlying 2D graphics engine
• 3D libraries - an implementation based on OpenGL ES 1.0 APIs; the libraries use
either hardware 3D acceleration (where available) or the included, highly optimized
3D software rasterizer
• FreeType - bitmap and vector font rendering
• SQLite - a powerful and lightweight relational database engine available to all
applications
Android Runtime
Android includes a set of core libraries that provides most of the functionality
available in the core libraries of the Java programming language.
Every Android application runs in its own process, with its own instance of the
12

13. Dalvik virtual machine. Dalvik has been written so that a device can run
multiple VMs efficiently. The Dalvik VM executes files in the Dalvik Executable
(.dex) format which is optimized for minimal memory footprint. The VM is
register-based, and runs classes compiled by a Java language compiler that
have been transformed into the .dex format by the included "dx" tool.
The Dalvik VM relies on the Linux kernel for underlying functionality such as
threading and low-level memory management.
Linux Kernel
Android relies on Linux version 2.6 for core system services such as security,
memory management, process management, network stack, and driver
model. The kernel also acts as an abstraction layer between the hardware
and the rest of the software stack.
Android SDK
You should update to the latest tools or platform using the Android SDK and
AVD Manager, rather than downloading a new SDK starter package.
http://dl.google.com/android/android-sdk_r16-macosx.zip
Here's an overview of the steps you must follow to set up the Android SDK:
1. Prepare your development computer and ensure it meets the system requirements.
2. Install the SDK starter package from the table above. (If you're on Windows,
download the installer for help with the initial setup.)
3. Install the ADT Plugin for Eclipse (if you'll be developing in Eclipse).
4. Add Android platforms and other components to your SDK.
5. Explore the contents of the Android SDK (optional).
13

14. System Requirements
Supported Operating Systems
• Windows XP (32-bit), Vista (32- or 64-bit), or Windows 7 (32- or 64-bit)
• Mac OS X 10.5.8 or later (x86 only)
• Linux (tested on Ubuntu Linux, Lucid Lynx)
o GNU C Library (glibc) 2.7 or later is required.
o On Ubuntu Linux, version 8.04 or later is required.
o 64-bit distributions must be capable of running 32-bit applications. For
information about how to add support for 32-bit applications
Supported Development Environments for Android SDK
Hardware requirements for Android SDK
The Android SDK requires disk storage for all of the components that you choose to install.
The table below provides a rough idea of the disk-space requirements to expect, based on
the components that you plan to use.
Component type Approximate size Comments
SDK Tools 35 MB Required.
SDK Platform-tools 6 MB Required.
Android platform (each) 150 MB At least one platform is required.
SDK Add-on (each) 100 MB Optional.
USB Driver for Windows 10 MB Optional. For Windows only.
Samples (per platform) 10M Optional.
Offline documentation 250 MB Optional.
Note that the disk-space requirements above are in addition to those of the Eclipse IDE, JDK,
or other prerequisite tools that you may need to install on your development computer.
14

15. Installing the SDK
Step 1. Preparing Your Development Computer
Before getting started with the Android SDK, take a moment to confirm that
your development computer meets the System Requirements. In particular,
you might need to install the JDK, if you don't have it already.
If you will be developing in Eclipse with the Android Development Tools (ADT)
Plugin—the recommended path if you are new to Android—make sure that
you have a suitable version of Eclipse installed on your computer as
described in the System Requirements document.
If you need to install Eclipse, you can download it from this location:
http://www.eclipse.org/downloads/
The "Eclipse Classic" version is recommended. Otherwise, a Java or RCP
version of Eclipse is recommended.
Step 2. Downloading the SDK Starter Package
The SDK starter package is not a full development environment—it includes
only the core SDK Tools, which you can use to download the rest of the SDK
components (such as the latest Android platform).
If you haven't already, get the latest version of the SDK starter package from
the SDK download page.
If you downloaded a .zip or .tgz package (instead of the SDK installer),
unpack it to a safe location on your machine. By default, the SDK files are
unpacked into a directory named android-sdk-<machine-platform>.
If you downloaded the Windows installer (.exe file), run it now and it will check
whether the proper Java SE Development Kit (JDK) is installed (installing it, if
necessary), then install the SDK Tools into a default location (which you can
modify).
15

16. Make a note of the name and location of the SDK directory on your system—
you will need to refer to the SDK directory later, when setting up the ADT
plugin and when using the SDK tools from the command line.
Step 3. Installing the ADT Plugin for Eclipse
Android offers a custom plugin for the Eclipse IDE, called Android
Development Tools (ADT), that is designed to give you a powerful, integrated
environment in which to build Android applications. It extends the capabilites
of Eclipse to let you quickly set up new Android projects, create an application
UI, debug your applications using the Android SDK tools, and even export
signed (or unsigned) APKs in order to distribute your application. In general,
developing in Eclipse with ADT is a highly recommended approach and is the
fastest way to get started with Android.
If you'd like to use ADT for developing Android applications, install it now.
Read Installing the ADT Plugin for step-by-step installation instructions, then
return here to continue the last step in setting up your Android SDK.
If you prefer to work in a different IDE, you do not need to install Eclipse or
ADT. Instead, you can directly use the SDK tools to build and debug your
application. The Introduction to Android application development outlines the
major steps that you need to complete when developing in Eclipse or other
IDEs.
Step 4. Adding Platforms and Other Components
The last step in setting up your SDK is using the Android SDK and AVD Manager (a tool
included in the SDK starter package) to download essential SDK components into your
development environment.
The SDK uses a modular structure that separates the major parts of the SDK—Android
platform versions, add-ons, tools, samples, and documentation—into a set of separately
installable components. The SDK starter package, which you've already downloaded,
includes only a single component: the latest version of the SDK Tools. To develop an Android
application, you also need to download at least one Android platform and the associated
platform tools. You can add other components and platforms as well, which is highly
16

17. recommended.
If you used the Windows installer, when you complete the installation wizard, it will launch
the Android SDK and AVD Manager with a default set of platforms and other components
selected for you to install. Simply click Install to accept the recommended set of
components and install them. You can then skip to Step 5, but we recommend you first read
the section about the Available Components to better understand the components available
from the Android SDK and AVD Manager.
You can launch the Android SDK and AVD Manager in one of the following ways:
• From within Eclipse, select Window > Android SDK and AVD Manager.
• On Windows, double-click the SDK Manager.exe file at the root of the Android SDK
directory.
• On Mac or Linux, open a terminal and navigate to the tools/ directory in the Android
SDK, then execute:
android
To download components, use the graphical UI of the Android SDK and AVD Manager to
browse the SDK repository and select new or updated components (see figure 1). The
Android SDK and AVD Manager installs the selected components in your SDK environment.
For information about which components you should download, see Recommended
Components.
17

18. Figure 1. The Android SDK and AVD Manager's Available Packages panel, which shows the
SDK components that are available for you to download into your environment.
Available Components
By default, there are two repositories of components for your SDK: Android Repository and
Third party Add-ons.
The Android Repository offers these types of components:
• SDK Tools — Contains tools for debugging and testing your application and other
utility tools. These tools are installed with the Android SDK starter package and
receive periodic updates. You can access these tools in the <sdk>/tools/ directory of
your SDK. To learn more about them, see SDK Tools in the developer guide.
• SDK Platform-tools — Contains platform-dependent tools for developing and
debugging your application. These tools support the latest features of the Android
platform and are typically updated only when a new platform becomes available.
You can access these tools in the <sdk>/platform-tools/ directory. To learn more
about them, see Platform Tools in the developer guide.
• Android platforms — An SDK platform is available for every production Android
platform deployable to Android-powered devices. Each SDK platform component
18

19. includes a fully compliant Android library, system image, sample code, and emulator
skins. To learn more about a specific platform, see the list of platforms that appears
under the section "Downloadable SDK Components" on the left part of this page.
• USB Driver for Windows (Windows only) — Contains driver files that you can install
on your Windows computer, so that you can run and debug your applications on an
actual device. You do not need the USB driver unless you plan to debug your
application on an actual Android-powered device. If you develop on Mac OS X or
Linux, you do not need a special driver to debug your application on an Android-
powered device. See Using Hardware Devices for more information about
developing on a real device.
• Samples — Contains the sample code and apps available for each Android
development platform. If you are just getting started with Android development,
make sure to download the samples to your SDK.
• Documentation — Contains a local copy of the latest multiversion documentation
for the Android framework API.
The Third party Add-ons provide components that allow you to create a development
environment using a specific Android external library (such as the Google Maps library) or a
customized (but fully compliant) Android system image. You can add additional Add-on
repositories by clicking Add Add-on Site.
Recommended Components
The SDK repository contains a range of components that you can download. Use the table
below to determine which components you need, based on whether you want to set up a
basic, recommended, or full development environment:
Environment SDK Component Comments
Basic SDK Tools If you've just installed the SDK starter package,
then you already have the latest version of this
component. The SDK Tools component is
required to develop an Android application.
Make sure you keep this up to date.
SDK Platform-
tools
This includes more tools that are required for
application development. These tools are
platform-dependent and typically update only
when a new SDK platform is made available, in
order to support new features in the platform.
These tools are always backward compatible
with older platforms, but you must be sure that
you have the latest version of these tools when
you install a new SDK platform.
SDK platform You need to download at least one platform into
your environment, so that you will be able to
compile your application and set up an Android
19

20. Virtual Device (AVD) to run it on (in the
emulator). To start with, just download the latest
version of the platform. Later, if you plan to
publish your application, you will want to
download other platforms as well, so that you
can test your application on the full range of
Android platform versions that your application
supports.
+
Recommended
(plus Basic)
Documentation The Documentation component is useful because
it lets you work offline and also look up API
reference information from inside Eclipse.
Samples The Samples components give you source code
that you can use to learn about Android, load as
a project and run, or reuse in your own app. Note
that multiple samples components are available
— one for each Android platform version. When
you are choosing a samples component to
download, select the one whose API Level
matches the API Level of the Android platform
that you plan to use.
Usb Driver The Usb Driver component is needed only if you
are developing on Windows and have an
Android-powered device on which you want to
install your application for debugging and
testing. For Mac OS X and Linux platforms, no
special driver is needed.
+
Full
(plus
Recommended)
Google APIs The Google APIs add-on gives your application
access to the Maps external library, which makes
it easy to display and manipulate Maps data in
your application.
Additional SDK
Platforms
If you plan to publish your application, you will
want to download additional platforms
corresponding to the Android platform versions
on which you want the application to run. The
recommended approach is to compile your
application against the lowest version you want
to support, but test it against higher versions
that you intend the application to run on. You
can test your applications on different platforms
20

21. by running in an Android Virtual Device (AVD) on
the Android emulator.
Once you've installed at least the basic configuration of SDK components, you're ready to
start developing Android apps. The next section describes the contents of the Android SDK
to familiarize you with the components you've just installed.
For more information about using the Android SDK and AVD Manager, see the Adding SDK
Components document.
Step 5. Exploring the SDK (Optional)
Once you've installed the SDK and downloaded the platforms, documentation, and add-ons
that you need, we suggest that you open the SDK directory and take a look at what's inside.
The table below describes the full SDK directory contents, with components installed.
Name Description
add-ons/ Contains add-ons to the Android SDK development environment, which
let you develop against external libraries that are available on some
devices.
docs/ A full set of documentation in HTML format, including the Developer's
Guide, API Reference, and other information. To read the
documentation, load the file offline.html in a web browser.
platform-tools/ Contains platform-dependent development tools that may be updated
with each platform release. The platform tools include the Android
Debug Bridge (adb) as well as other tools that you don't typically use
directly. These tools are separate from the development tools in the
tools/ directory because these tools may be updated in order to support
new features in the latest Android platform.
platforms/ Contains a set of Android platform versions that you can develop
applications against, each in a separate directory.
<platform>/ Platform version directory, for example "android-11". All platform
version directories contain a similar set of files and subdirectory
structure. Each platform directory also includes the Android library
(android.jar) that is used to compile applications against the platform
version.
samples/ Sample code and apps that are specific to platform version.
21

22. tools/ Contains the set of development and profiling tools that are platform-
independent, such as the emulator, the Android SDK and AVD Manager,
ddms, hierarchyviewer and more. The tools in this directory may be
updated at any time using the Android SDK and AVD Manager and are
independent of platform releases.
SDK Readme.txt A file that explains how to perform the initial setup of your SDK,
including how to launch the Android SDK and AVD Manager tool on all
platforms.
SDK
Manager.exe
Windows SDK only. A shortcut that launches the Android SDK and AVD
Manager tool, which you use to add components to your SDK.
Optionally, you might want to add the location of the SDK's tools/ and platform-tools to your
PATH environment variable, to provide easy access to the tools.
Android's Features
Handset layouts
The platform is adaptable to larger, VGA, 2D graphics library, 3D graphics library
based on OpenGL ES 2.0 specifications, and traditional smartphone layouts.
Storage
SQLite, a lightweight relational database, is used for data storage purposes.
Connectivity
Android supports connectivity technologies including GSM/EDGE, IDEN, CDMA, EV-
DO, UMTS, Bluetooth, Wi-Fi, LTE, NFC and WiMAX.
Messaging
SMS and MMS are available forms of messaging, including threaded text messaging
and now Android Cloud To Device Messaging (C2DM) is also a part of Android Push
Messaging service.
Multiple language support
Android supports multiple languages.
Web browser
The web browser available in Android is based on the open-source WebKit layout
engine, coupled with Chrome's V8 JavaScript engine. The browser scores 100/100 on
the Acid3 test on Android 4.0.
Java support
22

23. While most Android applications are written in Java, there is no Java Virtual Machine
in the platform and Java byte code is not executed. Java classes are compiled into
Dalvik executables and run on Dalvik, a specialized virtual machine designed
specifically for Android and optimized for battery-powered mobile devices with
limited memory and CPU. J2ME support can be provided via third-party applications.
Media support
Android supports the following audio/video/still media formats: WebM, H.263,
H.264 (in 3GP or MP4 container), MPEG-4 SP, AMR, AMR-WB (in 3GP container),
AAC, HE-AAC (in MP4 or 3GP container), MP3, MIDI, Ogg Vorbis, FLAC, WAV, JPEG,
PNG, GIF, BMP.[71]
Streaming media support
RTP/RTSP streaming (3GPP PSS, ISMA), HTML progressive download (HTML5 <video>
tag). Adobe Flash Streaming (RTMP) and HTTP Dynamic Streaming are supported by
the Flash plugin. Apple HTTP Live Streaming is supported by RealPlayer for Android,
and by the operating system in Android 3.0 (Honeycomb).
Additional hardware support
Android can use video/still cameras, touchscreens, GPS, accelerometers, gyroscopes,
barometers, magnetometers, dedicated gaming controls, proximity and pressure
sensors, thermometers, accelerated 2D bit blits (with hardware orientation, scaling,
pixel format conversion) and accelerated 3D graphics.
Multi-touch
Android has native support for multi-touch which was initially made available in
handsets such as the HTC Hero. The feature was originally disabled at the kernel
level (possibly to avoid infringing Apple's patents on touch-screen technology at the
time). Google has since released an update for the Nexus One and the Motorola
Droid which enables multi-touch natively.
Bluetooth
Supports A2DP, AVRCP, sending files (OPP), accessing the phone book (PBAP), voice
dialing and sending contacts between phones. Keyboard, mouse and joystick (HID)
support is available in Android 3.1+, and in earlier versions through manufacturer
customizations and third-party applications.
Video calling
Android does not support native video calling, but some handsets have a customized
version of the operating system that supports it, either via the UMTS network (like
the Samsung Galaxy S) or over IP. Video calling through Google Talk is available in
Android 2.3.4 and later. Gingerbread allows Nexus S to place Internet calls with a SIP
account. This allows for enhanced VoIP dialing to other SIP accounts and even phone
23

24. numbers. Skype 2.1 offers video calling in Android 2.3, including front camera
support.
Multitasking
Multitasking of applications is available.
Voice based features
Google search through voice has been available since initial release. Voice actions
for calling, texting, navigation, etc. are supported on Android 2.2 onwards.
Tethering
Android supports tethering, which allows a phone to be used as a wireless/wired Wi-
Fi hotspot. Before Android 2.2 this was supported by third-party applications or
manufacturer customizations.
Screen capture
Android supports capturing a screenshot by pressing the power and volume-down
buttons at the same time. Prior to Android 4.0, the only methods of capturing a
screenshot were through manufacturer and third-party customizations or otherwise
by using a PC connection (DDMS developer's tool). These alternative methods are
still available with the latest Android.
External storage
Most Android devices include microSD slot and can read microSD cards formatted
with FAT32, Ext3fs or Ext4fs file system. To allow use of high-capacity storage media
such as USB flash drives and USB HDDs, many Android tablets also include USB 'A'
receptacle. Storage formatted with FAT32 is handled by Linux Kernel VFAT driver,
while 3rd party solutions are required to handle other popular file systems such as
NTFS, HFS Plus and exFAT.
1. THE CLIENT TIER:
Also called as the client layer comprises of components that are dedicated
to presenting the data to the user. For example: Android screens etc.
24

25. 2. THE MIDDLE LAYER
This layer encapsulates the Business rules or the business logic of the
encapsulations. To have a separate layer for business logic is of a great advantage.
This is because any changes in Business Rules can be easily handled in this layer. As
long as the interface between the layers remains the same, any changes to the
functionality/processing logic in this layer can be made without impacting the
others. A lot of client-server apps failed to implement successfully as changing the
business logic was a painful process
3. THE DATA BASE LAYER
This layer comprises of components that help in accessing the Database. If
used in the right way, this layer provides a level of abstraction for the database
structures. Simply put changes made to the database, tables, etc do not affect the
rest of the application because of the Data Access layer. The different application
layers send the data requests to this layer and receive the response from this layer.
3. THE DATABASE LAYER
This layer comprises of the Database Components such as DB Files, Tables,
Views, etc. The Actual database could be created using SQLite, . In an n-tier
application, the entire application can be implemented in such a way that it is
independent of the actual Database. For instance, you could change the Database
Location with minimal changes to Data Access Layer. The rest of the Application
should remain unaffected.
5.SYSTEM DESIGN
Unified Modeling Language:
The Unified Modeling Language allows the software engineer to express an
25

26. analysis model using the modeling notation that is governed by a set of syntactic
semantic and pragmatic rules.A UML system is represented using five different views
that describe the system from distinctly different perspective. Each view is defined by
a set of diagram, which is as follows.
• User Model View
i. This view represents the system from the users perspective.
ii. The analysis representation describes a usage scenario from the
end-users perspective.
• Structural model view
i. In this model the data and functionality are arrived from inside
the system.
ii. This model view models the static structures.
• Behavioral Model View
It represents the dynamic of behavioral as parts of the system,
depicting the interactions of collection between various structural
elements described in the user model and structural model view.
• Implementation Model View
In this the structural and behavioral as parts of the system are
represented as they are to be built.
• Environmental Model View
In this the structural and behavioral aspects of the environment in
which the system is to be implemented are represented
UML is specifically constructed through two different domains they
are:
UML Analysis modeling, this focuses on the user model and structural model
views of the system.UML design modeling, which focuses on the behavioral
26

27. modeling, implementation modeling and environmental model views
Use case Diagrams represent the functionality of the system from a user’s point of
view. Use cases are used during requirements elicitation and analysis to represent the
functionality of the system. Use cases focus on the behavior of the system from
external point of view. Actors are external entities that interact with the system.
Examples of actors include users like administrator, bank customer …etc., or another
system like central database.
6. UML DIAGRAMS
Use case diagram:
27

28. Fig: use case diagram for Shopper and user
Activity diagram:
Fig:
activity diagram
Sequence diagram:
28

29. Sequence diagram: (admin)
Fig: Sequence diagram for admin
29

30. 7. SYSTEM TESTING
SYSTEM TESTING
The purpose of testing is to discover errors. Testing is the process
of trying to discover every conceivable fault or weakness in a work
product. It provides a way to check the functionality of components, sub
assemblies, assemblies and/or a finished product It is the process of
exercising software with the intent of ensuring that the
Software system meets its requirements and user expectations and does
30

31. not fail in an unacceptable manner. There are various types of test. Each
test type addresses a specific testing requirement.
TYPES OF TESTS
Unit testing
Unit testing involves the design of test cases that validate that the
internal program logic is functioning properly, and that program inputs
produce valid outputs. All decision branches and internal code flow
should be validated. It is the testing of individual software units of the
application .it is done after the completion of an individual unit before
integration. This is a structural testing, that relies on knowledge of its
construction and is invasive. Unit tests perform basic tests at component
level and test a specific business process, application, and/or system
configuration. Unit tests ensure that each unique path of a business
process performs accurately to the documented specifications and
contains clearly defined inputs and expected results.
Integration testing
31

32. Integration tests are designed to test integrated software
components to determine if they actually run as one program. Testing is
event driven and is more concerned with the basic outcome of screens
or fields. Integration tests demonstrate that although the components
were individually satisfaction, as shown by successfully unit testing, the
combination of components is correct and consistent. Integration testing
is specifically aimed at exposing the problems that arise from the
combination of components.
Functional test
Functional tests provide systematic demonstrations that functions
tested are available as specified by the business and technical
requirements, system documentation, and user manuals.
Functional testing is centered on the following items:
Valid Input : identified classes of valid input must be accepted.
Invalid Input : identified classes of invalid input must be rejected.
Functions : identified functions must be exercised.
Output : identified classes of application outputs must be
exercised.
Systems/Procedures: interfacing systems or procedures must be
invoked.
32

33. Organization and preparation of functional tests is focused on
requirements, key functions, or special test cases. In addition, systematic
coverage pertaining to identify Business process flows; data fields,
predefined processes, and successive processes must be considered for
testing. Before functional testing is complete, additional tests are
identified and the effective value of current tests is determined.
System Test
System testing ensures that the entire integrated software system
meets requirements. It tests a configuration to ensure known and
predictable results. An example of system testing is the configuration
oriented system integration test. System testing is based on process
descriptions and flows, emphasizing pre-driven process links and
integration points.
White Box Testing
White Box Testing is a testing in which in which the software tester
has knowledge of the inner workings, structure and language of the
software, or at least its purpose. It is purpose. It is used to test areas that
cannot be reached from a black box level.
Black Box Testing
Black Box Testing is testing the software without any knowledge of
the inner workings, structure or language of the module being tested.
Black box tests, as most other kinds of tests, must be written from a
33

34. definitive source document, such as specification or requirements
document, such as specification or requirements document. It is a
testing in which the software under test is treated, as a black box .you
cannot “see” into it. The test provides inputs and responds to outputs
without considering how the software works.
Unit Testing:
Unit testing is usually conducted as part of a combined code and
unit test phase of the software lifecycle, although it is not uncommon for
coding and unit testing to be conducted as two distinct phases.
Test strategy and approach
Field testing will be performed manually and
functional tests will be written in detail.
Test objectives
• All field entries must work properly.
• Pages must be activated from the identified link.
• The entry screen, messages and responses must not
be delayed.
Features to be tested
34

35. • Verify that the entries are of the correct format
• No duplicate entries should be allowed
• All links should take the user to the correct page.
Integration Testing
Software integration testing is the incremental integration testing
of two or more integrated software components on a single platform to
produce failures caused by interface defects.
The task of the integration test is to check that components or
software applications, e.g. components in a software system or – one
step up – software applications at the company level – interact without
35

36. error.
Test Results: All the test cases mentioned above passed successfully. No
defects encountered.
Acceptance Testing
User Acceptance Testing is a critical phase of any project and
requires significant participation by the end user. It also ensures that the
system meets the functional requirements.
Test Results: All the test cases mentioned above passed successfully. No
defects encountered.
8. SCREEN SHOTS
36

37. 9. LIMITATIONS AND SCOPE FOR FUTURE
ENHANCEMENTS
Limitations of the system:.
• System works in all platforms and its compatible environments.
• Advanced techniques are not used to check the authorization.
• No online
Future Enhancements:
It is not possible to develop a system that makes all the requirements of the user.
User requirements keep changing as the system is being used. Some of the future
enhancements that can be done to this system are:
• As the technology emerges, it is possible to upgrade the system and can be
online.
• Because it is based on object-oriented design, any further changes can be
easily adaptable.
• Based on the future security issues, security can be improved using emerging
technologies.
• GPS can be added
37

38. 10. CONCLUSION
PROJECT SUMMARY:
This application software has been computed successfully and was also tested
successfully by taking “test cases”. It is user friendly, and has required options, which
can be utilized by the user to perform the desired operations.
The software is developed using as front end and SQLite as back end in
Windows environment. The goals that are achieved by the software are:
 Optimum utilization of resources.
 Efficient management of records.
 Simplification of the operations.
 Less processing time and getting required information.
 User friendly.
 Portable and flexible for further enhancement.
WORK DONE:
This is the web enabled project .this project offers user to enter the data to simple and
interactive forms .this is very helpful to the client to enter desired information through
so much simplicity
.GOALS
• Reduced entry work
• Easy retrieval of information
• Reduced errors due to human intervention
• User friendly screens to enter the data
• Portable and flexible for further enhancement
• Fast finding of information requested
38

39. BIBILIOGRAPHY
References Made From:
Beginning Android 4 Application Development by Wei-Meng Lee
Beginning Android By Mark Murphy
Professional Android 2 Application Development by Reto Meier(Wrox)
Introducing Android Development with Ice Cream Sandwich by Shane
Conder, Lauren Darcey
Sams Teach Yourself Java in 24 Hours (Covering Java 7 and Android) By
Rogers Cadenhead
Programming Android By Zigurd Mednieks, Laird Dornin, G. Blake Meike,
Masumi Nakamura
Amazing Android Apps For Dummies by Daniel A.Begun
Developing Android Applications with Flex 4.5 By Rich Tretola
Sites Referred:
http://developer.android.com/guide/index.html§
http://www.codeproject.com/Articles/102065/Android-A-beginner-s-
guide§
http://mobile.dzone.com/articles/fundamentals-android-tutorial§
http://mobile.tutsplus.com/tutorials/android/java-tutorial/§
39

40. 40