Download CONTENTS Abstract----------------------------------------------------------

CONTENTS
_______________________________________
1. Abstract-----------------------------------------------------------1
2. Introduction ------------------------------------------------------2
3. Using an Android Emulator------------------------------------3
4. Developmental environment-----------------------------------2
5. Descriptions of the APIs---------------------------------------4
6. Picture of the demo --------------------------------------------6
7. Application flow diagrams
8. Overview
9. Problems you faced during design and implementation-11
10. Development Environment
ABSTRACT
With Google’s latest launch for mobile Android Operating System, I did
a project starting from Call Dropper of it up to Creating Basic
Application. Here I described about Android, features, capabilities,
application, what we developed, current market scenario and future
plans. Here I am making an application where describing the use of GPS
as well as some advance calling functionality. As in current busy human
like we are getting some unwanted calls that we simply want to cut on,
this application gives us the power so.
INTRODUCTION
Everywhere you go, people are using mobile devices to keep in touch
with family and friends, take a picture to post on a social website, find
the location of a restaurant, or check the latest news headlines. Mobile
devices come in many different shapes and styles. Mobile phones run a
variety of different operating systems such as Apple's OS, Google's
Android, and Research in Motion's Blackberry. Some have large
displays, physical keyboards, and run on 3G, 4G, or WiFi networks.
Mobile phones may also have sensors for acceleration, location, or even
payments. Some of these devices aren't even phones; they're tablets with
larger displays and a data-only network connection.
In this age we require an application in our pocket which keep remember
out friend as well as the persons to whom we don’t want to talk. This
application gives the such power to the user. Here you can simply mark
that mobile no. as spam and then this application will automatically
disconnect subsequent calls from that number.
Using the ANDROID EMULATOR
The Android SDK includes a virtual mobile device emulator that runs on
your computer. The emulator lets you prototype, develop and test
Android applications without using a physical device.
The Android emulator mimics all of the hardware and software features
of a typical mobile device, except that it cannot place actual phone calls.
It provides a variety of navigation and control keys, which you can
"press" using your mouse or keyboard to generate events for your
application. It also provides a screen in which your application is
displayed, together with any other active Android applications.
To let you model and test your application more easily, the emulator
utilizes Android Virtual Device (AVD) configurations. AVDs let you
define certain hardware aspects of your emulated phone and allow you
to create many configurations to test many Android platforms and
hardware permutations. Once your application is running on the
emulator, it can use the services of the Android platform to invoke other
applications, access the network, play audio and video, store and retrieve
data, notify the user, and render graphical transitions and themes.
The emulator also includes a variety of debug capabilities, such as a
console from which you can log kernel output, simulate application
interrupts (such as arriving SMS messages or phone calls), and simulate
latency effects and dropouts on the data network.
Descriptions of the API:
1. Broad Cast Receiver : This API used to listen the Incoming call
event for that we need to add two permissions as well to the
android manifest file i.e. READ_PHONE_STATE and
CALL_PHONE.
2. Location Listener: This API used to listen the GPS location
changes for this also we need to add application permission under
android manifest file i.e. ACCESS_FINE_LOCATION,
ACCESS_COARSE_LOCATION
3. Telephony Manager: This API to interact with the native GSM call
interaction as we require to end the call.
4. Intent: This is a massager king thing I used it to launch a new
activity.
5. Activity: It works like a screen where we are displaying all the UI
component.
6. SQLite Open Helper: This API used to handle the database
operation.
Picture of the Demo
Application flow diagram
Incoming Call
If No. spam
mark count is >3
User Clicked on the application icon
No
Display Call droaper
Screen with Lat
Long information
and Spam Button
Yes
Spam Button Click
Simply disconnect
the call
If Any Active Call is
there
Disconnect the call and
increase the Spam count is
the Database.
OVERVIEW
The Android emulator is an application that provides a virtual mobile
device on which you can run your Android applications. It runs a full
Android system stack, down to the kernel level, that includes a set of
preinstalled applications (such as the dialer) that you can access from
your applications. You can choose what version of the Android system
you want to run in the emulator by configuring AVDs, and you can also
customize the mobile device skin and key mappings. When launching
the emulator and at runtime, you can use a variety of commands and
options to control its behavior.
The Android system images available through the Android SDK
Manager contain code for the Android Linux kernel, the native libraries,
the Dalvik VM, and the various Android packages (such as the Android
framework and preinstalled applications). The emulator provides
dynamic binary translation of device machine code to the OS and
processor architecture of your development machine.
The Android emulator supports many hardware features likely to be
found on mobile devices, including:







An ARMv5 CPU and the corresponding memory-management unit
(MMU)
A 16-bit LCD display
One or more keyboards (a Qwerty-based keyboard and associated
Dpad/Phone buttons)
A sound chip with output and input capabilities
Flash memory partitions (emulated through disk image files on the
development machine)
A GSM modem, including a simulated SIM Card
A camera, using a webcam connected to your development
computer.
Problems faced during implementation
1. While launching the sample application, its not running. Only the
emulator (android) screen is displayed but our sample app is not
deployed.
2. Many times the installer time out.
[ERROR] Timed out waiting for emulator to be ready, you may need to
close the emulator and try again [ERROR] Application Installer
abnormal process termination. Process exit value was 1.
3. Some application sample examples like ToDo List is able to run but
many times it stop running in the emulator.
Titanium SDK 2.0.2 Android SDK 2.2 jdk 6 windows 7 (32 bit)
4. Then main problem that I faced was there was no such API I found
to disconnect the call programmatically. I did a lot of surfing and
read a lot about google API and forums then after I found the way
to disconnect the calls using Telephony API.
5. Here also I faced some issue how to listing the incoming call
event. And how to launch the new Activity with the incoming call
details. But finally by going through the API I found so. Google
API are really good they documented the things properly that was
the main positive point for me to develop this peroject.
DEVELOPEMENTAL ENVIRONMENT
Java version 1.6
Android SDK using 2.1 API level 7
Editor Used: Eclipse
Tools
The Android SDK includes a variety of tools that help you develop
mobile applications for the Android platform. The tools are classified
into two groups: SDK tools and platform tools. SDK tools are platform
independent and are required no matter which Android platform you are
developing on. Platform tools are customized to support the features of
the latest Android platform.
Here I using eclipse to write the code and ADT (Android Development
toolkit) to communicate with the Android SDK tools.
I have taken the help from Android document site the setup the
development environment some of the point from them are bellow:
1. Download eclipse from http://eclipse.org/mobile/ and install.
2. Start Eclipse, then select Help > Install New Software.
3.
Click
Add,
in
the
top-right
corner.
4. In the Add Repository dialog that appears, enter "ADT Plugin" for the
Name and the following URL for the Location:
https://dl-ssl.google.com/android/eclipse/
5. Click OK.
6. In the Available Software dialog, select the checkbox next to
Developer Tools and click Next.
7. In the next window, you'll see a list of the tools to be downloaded.
Click Next.
8. Download and install Android SDK from
http://developer.android.com/sdk/index.html and then restart you eclips.
9. Now in eclipse go the windows -> preferences -> there select Android
and give the android SDK path where you installed at step 8.
SDK Tools
The SDK tools are installed with the SDK starter package and are
periodically updated. The SDK tools are required if you are developing
Android applications. The most important SDK tools include the
Android SDK Manager (android sdk), the AVD Manager
(android avd) the emulator (emulator), and the Dalvik Debug
Monitor Server (ddms). A short summary of some frequently-used SDK
tools is provided below.
android
Lets you manage AVDs, projects, and the installed components of
the SDK.
Dalvik Debug Monitor Server (ddms)
Lets you debug Android applications.
dmtracedump
Generates graphical call-stack diagrams from trace log files. The
tool uses the Graphviz Dot utility to create the graphical output, so
you need to install Graphviz before running dmtracedump. For
more information on using dmtracedump, see Profiling with
Traceview and dmtracedump
Draw 9-patch
Allows you to easily create a NinePatch graphic using a
WYSIWYG editor. It also previews stretched versions of the
image, and highlights the area in which content is allowed.
Android Emulator (emulator)
A QEMU-based device-emulation tool that you can use to design,
debug, and test your applications in an actual Android run-time
environment.
Hierarchy Viewer (hierarchyviewer)
Lets you debug and optimize an Android application's user
interface.
hprof-conv
Converts the HPROF file that is generated by the Android SDK
tools to a standard format so you can view the file in a profiling
tool of your choice.
layoutopt
Lets you quickly analyze your application's layouts in order to
optimize them for efficiency.
mksdcard
Helps you create a disk image that you can use with the emulator,
to simulate the presence of an external storage card (such as an SD
card).
Monkey
Runs on your emulator or device and generates pseudo-random
streams of user events such as clicks, touches, or gestures, as well
as a number of system-level events. You can use the Monkey to
stress-test applications that you are developing, in a random yet
repeatable manner.
monkeyrunner
Provides an API for writing programs that control an Android
device or emulator from outside of Android code.
ProGuard
Shrinks, optimizes, and obfuscates your code by removing unused
code and renaming classes, fields, and methods with semantically
obscure names.
Systrace
Lets you analyze the execution of your application in the context
of system processes, to help diagnose display and performance
issues.
sqlite3
Lets you access the SQLite data files created and used by Android
applications.
traceview
Provides a graphical viewer for execution logs saved by your
application.
zipalign
Optimizes .apk files by ensuring that all uncompressed data starts
with a particular alignment relative to the start of the file. This
should always be used to align .apk files after they have been
signed.
Platform Tools
The platform tools are typically updated every time you install a new
SDK platform. Each update of the platform tools is backward
compatible with older platforms. Usually, you directly use only one of
the platform tools—the Android Debug Bridge (adb). Android Debug
Bridge is a versatile tool that lets you manage the state of an emulator
instance or Android-powered device. You can also use it to install an
Android application (.apk) file on a device.
The other platform tools, such as aidl, aapt, dexdump, and dx, are
typically called by the Android build tools or Android Development
Tools (ADT), so you rarely need to invoke these tools directly. As a
general rule, you should rely on the build tools or the ADT plugin to call
them as needed.