Using an Android Emulator------------------------------------3
Descriptions of the APIs---------------------------------------4
Picture of the demo --------------------------------------------6
Application flow diagrams
Problems you faced during design and implementation-11
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.
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:
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.
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
Telephony Manager: This API to interact with the native GSM call interaction as we require to end the call.
Intent: This is a massager king thing I used it to launch a new activity.
Activity: It works like a screen where we are displaying all the UI component.
SQLite Open Helper: This API used to handle the database operation.
Picture of the Demo
Application flow diagram
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
While launching the sample application, its not running. Only the emulator (android) screen is displayed but our sample app is not deployed.
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.
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)
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.
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.
Java version 1.6
Android SDK using 2.1 API level 7
Editor Used: Eclipse
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:
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.
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.
Lets you manage AVDs, projects, and the installed components of the SDK.
Dalvik Debug Monitor Server (ddms)
Lets you debug Android applications.
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
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.
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.
Lets you quickly analyze your application's layouts in order to optimize them for efficiency.
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).
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.
Provides an API for writing programs that control an Android device or emulator from outside of Android code.
Shrinks, optimizes, and obfuscates your code by removing unused code and renaming classes, fields, and methods with semantically obscure names.
Lets you analyze the execution of your application in the context of system processes, to help diagnose display and performance issues.
Lets you access the SQLite data files created and used by Android applications.
Provides a graphical viewer for execution logs saved by your application.
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.
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.