Monday, 1 August 2011

Android development

Introduction to Android development


The BlackBerry and iPhone, which have appealing and high-volume mobile
platforms, are addressing opposite ends of a spectrum. The
BlackBerry is rock-solid for the enterprise business user. For a
consumer device, it's hard to compete with the iPhone for ease of use and
the "cool factor." Android, a young and yet-unproven platform,
has the potential to play at both ends of the mobile-phone spectrum and
perhaps even bridge the gulf between work and play.

Today, many network-based or network-capable appliances
run a flavor of the Linux kernel. It's a solid platform: cost-effective
to deploy and support and readily accepted as a good design
approach for deployment. The UI for such devices
is often HTML-based and viewable with a PC or Mac browser. But not every
appliance needs to be controlled by a general computing device. Consider a conventional appliance, such as a stove, microwave or
bread maker. What if your household appliances were controlled by Android
and boasted a color touch screen? With an Android UI on the
stove-top, the author might even be able to cook something.

In this article, learn about
the Android platform and how it can be used for mobile and
nonmobile applications. Install the Android
SDK and build a simple application. Download the source code for the example application in this article.

A brief history of Android

The Android platform is the product of the Open
Handset Alliance
, a group of organizations collaborating to
build a better mobile phone. The group, led by Google, includes mobile operators, device handset manufacturers,
component manufacturers, software solution and platform providers, and
marketing companies. From a software development standpoint, Android sits
smack in the middle of the open source world.

The first Android-capable handset on the market was the G1 device
manufactured by HTC and provisioned on T-Mobile. The device
became available after almost a year of speculation, where the only
software development tools available were some incrementally improving
SDK releases. As the G1 release date
neared, the Android team released SDK V1.0 and applications began
surfacing for the new platform.

To spur innovation, Google sponsored two
rounds of "Android Developer Challenges," where millions of dollars were
given to top contest submissions. A few months after the
G1, the Android Market was released, allowing users to browse and download
applications directly to their phones. Over about 18 months, a
new mobile platform entered the public arena.

The Android platform

With Android's breadth of capabilities, it would be easy to confuse
it with a desktop operating system. Android is a layered environment built
upon a foundation of the Linux kernel, and it includes rich functions. The
UI subsystem includes:

  • Windows
  • Views
  • Widgets for displaying common elements such as edit boxes, lists, and drop-down lists

Android includes an embeddable browser built upon WebKit, the same open source browser
engine powering the iPhone's Mobile Safari browser.

Android boasts a healthy array of connectivity options, including WiFi,
Bluetooth, and wireless data over a cellular connection (for
example, GPRS, EDGE, and 3G). A popular technique in Android applications
is to link to Google Maps to display an address directly within an
application. Support for location-based services (such as GPS) and
accelerometers is also available in the Android software stack, though not
all Android devices are equipped with the required hardware. There is also
camera support.

Historically, two areas where mobile applications have struggled to keep
pace with their desktop counterparts are graphics/media, and data storage
methods. Android addresses the graphics challenge with built-in support
for 2-D and 3-D graphics, including the OpenGL library. The data-storage burden is eased because the Android platform includes the popular
open source SQLite database. Figure 1 shows a simplified view of the Android software layers.

Figure 1. Android software layers

The Android software layers

Application architecture

As mentioned, Android runs atop a Linux kernel. Android applications are
written in the Java programming language, and they
run within a virtual machine (VM). It's important to note that
the VM is not a JVM as you might expect, but
is the Dalvik Virtual Machine, an open source technology. Each
Android application runs within an instance of the Dalvik VM, which in
turn resides within a Linux-kernel managed process, as shown below.

Figure 2. Dalvik VM

Dalvik VM

An Android application consists of one or more of the following

An application that has a visible UI is implemented with an activity. When a user selects an application from the home screen or application launcher, an activity is started.
A service should be used for any application that needs to persist for a long time, such as a network monitor or update-checking application.
Content providers
You can think of content providers as a database server. A content provider's job is to manage access to persisted data, such as a SQLite database. If your application is very simple, you might not necessarily create a content provider. If you're building a larger application, or one that makes data available to multiple activities or applications, a content provider is the means of accessing your data.
Broadcast receivers
An Android application may be launched to process a element of data or respond to an event, such as the receipt of a text message.

An Android application, along with a file called
AndroidManifest.xml, is deployed to a device. AndroidManifest.xml contains the necessary configuration
information to properly install it to the device. It
includes the required class names and types of events the application
is able to process, and the required permissions the application needs to
run. For example, if an application requires access to the network — to
download a file, for example — this permission must be explicitly stated
in the manifest file. Many applications may have this specific
permission enabled. Such declarative security helps reduce the
likelihood that a rogue application can cause damage on your device.

The next section discusses the development environment required to build an
Android application.

Required tools

The easiest way to start developing Android applications is to
download the Android SDK and the Eclipse IDE (see Resources). Android development can take
place on Microsoft® Windows®, Mac OS X, or Linux.

This article assumes you are using the Eclipse IDE and the Android
Developer Tools plug-in for Eclipse. Android
applications are written in the Java language, but compiled and
executed in the Dalvik VM (a non-Java virtual machine). Coding in the Java language
within Eclipse is very intuitive; Eclipse provides a rich Java
environment, including context-sensitive help and code suggestion hints.
Once your Java code is compiled cleanly, the Android Developer Tools make
sure the application is packaged properly, including the
AndroidManifest.xml file.

It's possible to develop Android applications without Eclipse and the
Android Developer Tools plug-in, but you would need to know
your way around the Android SDK.

The Android SDK is distributed as a ZIP file that unpacks to a directory
on your hard drive. Since there have been several SDK updates, it is
recommended that you keep your development environment well organized so you can
easily switch between SDK installations. The SDK

Java archive file containing all of the Android SDK classes necessary to build your application.
documention.html and docs directory
The SDK documentation is provided locally and on the Web. It's largely in the form of JavaDocs, making it easy to navigate the many packages in the SDK. The documentation also includes a high-level Development Guide and links to the broader Android community.
Samples directory
The samples subdirectory contains full source code for a variety of applications, including ApiDemo, which exercises many APIs. The sample application is a great place to explore when starting Android application development.
Tools directory
Contains all of the command-line tools to build Android applications. The most commonly employed and useful tool is the adb utility (Android Debug Bridge).
Directory containing the necessary drivers to connect the development environment to an Android-enabled device, such as the G1 or the Android Dev 1 unlocked development phone. These files are only required for developers using the Windows platform.

Android applications may be run on a real device or on the Android
Emulator, which ships with the Android SDK. Figure 3 shows the Android
Emulator's home screen.

Figure 3. Android Emulator

The Android Emulator

Android Debug Bridge

The adb utility
supports several optional command-line arguments that provide
powerful features, such as copying files to and from the device. The shell
command-line argument lets you connect to the phone itself and issue
rudimentary shell commands. Figure 4 shows the adb shell
command against a real device connected to a Windows laptop with a USB

Figure 4. Using the adb shell

Using the adb shell command

Within this shell environment, you can:

  • Display the network configuration that shows multiple network
    connections. Note the multiple network connections:
    • lo is the local or loopback connection.
    • tiwlan0 is the WiFi connection with an
      address provisioned by a
      local DHCP server.
  • Display the contents of the PATH environment variable.
  • Execute the su command to become the
  • Change the directory to /data/app, where user applications are
  • Do a directory listing where you see a single application. Android
    application files are actually archive files that are viewable with WinZip or
    equivalent. The extension is apk.
  • Issue a ping command to see if is available.

From this same command-prompt environment, you can also interact with SQLite
databases, start programs, and many other system-level tasks. This is
fairly remarkable function, considering you're connected to a

In the next section, you'll create a simple
Android application.

Coding a basic

This section provides a whirlwind tour of building an Android application.
The example application is about as simple as you can imagine: a
modified "Hello Android" application. You'll add a minor modification to
make the screen background color all white so you can use the
phone as a flashlight. Not very original, but it will be useful
as an example. Download the full
source code.

To create an application in Eclipse, select File > New >
Android project
, which starts the New Android Project wizard.

Figure 5. New Android project

The new Android project wizard

Next, you create a simple application with a single activity, along with a
UI layout stored in main.xml. The layout contains a text
element you're going to modify to say Android FlashLight. The simple
layout is shown below.

Listing 1. Flashlight layout
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android=""
    android:text="@string/hello" android:textColor="@color/all_black" 


Create a couple of color resources in strings.xml.

Listing 2. Color in strings.xml
<?xml version="1.0" encoding="utf-8"?>
    <string name="hello">Android FlashLight</string>

    <string name="app_name">FlashLight</string>
    <color name="all_white">#FFFFFF</color>
    <color name="all_black">#000000</color>

The main screen layout has a background color defined as all_white.
In the strings.xml file, you see that all_white is defined as an
RGB triplet value of #FFFFFF, or all white.

The layout contains a single TextView, which is really just a piece of
static text; it is not editable. The text is set to be black
and is centered horizontally with the gravity attribute.

The application has a Java source file called, as shown below.

Listing 3.
package com.msi.flashlight;
import android.os.Bundle;
public class FlashLight extends Activity {
    /** Called when the activity is first created. */
    public void onCreate(Bundle savedInstanceState) {

The code is boiler-plate directly from the New Project wizard:

  • It is part of a Java package called com.msi.flashlight.
  • It has two imports:
    • One for the activity class
    • One for the bundle class
  • When this activity is initiated, the onCreate method is invoked,
    passing in a savedInstanceState. Don't be
    concerned with this bundle
    for our purposes; it is used when an activity is suspended and then
  • The onCreate method is an override of the activity class method of the
    same name. It calls the super class's onCreate method.
  • A call to setContentView() associates the UI layout
    defined in the file main.xml. Anything in main.xml and strings.xml gets automatically mapped to
    constants defined in the source file. Never edit this file
    directly, as it is changed upon every build.

Running the application presents a white screen with black text.

Figure 6. White screen of

White screen of flashlight

The AndroidManifest.xml file
setup for the FlashLight application is shown below.

Listing 4. AndroidManifest.xml for FlashLight
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android=""
    <application android:icon="@drawable/icon" android:label="@string/app_name">
        <activity android:name=".FlashLight"
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />

This file was created automatically by the Android Developer
Tools plug-in for Eclipse. You didn't have to do anything.

Of course, the application is not terribly magnificent. But it could come
in handy if you want to do some reading without disturbing your sleeping
spouse, or if you need to find your way to the fuse box in the basement during a power

1 comment:

  1. Hello...Image is not displayed. Can u see to it.