Introduction to Android development
The open source appliance platformIntroduction
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.
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.
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 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
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
An Android application consists of one or more of the following classifications:
- Activities
- 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.
- Services
- 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.
The next section discusses the development environment required to build an Android application.
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 includes:
- android.jar
- 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). - usb_driver
- 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.
Figure 3. 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
cable.Figure 4. Using the
adb
shell
commandWithin 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 super-user. - Change the directory to /data/app, where user applications are stored.
- 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 Google.com is available.
In the next section, you'll create a simple Android application.
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 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
Create a couple of color resources in strings.xml.
Listing 2. Color in strings.xml
|
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 FlashLight.java, as shown below.
Listing 3. Flashlight.java
package com.msi.flashlight; import android.app.Activity; import android.os.Bundle; public class FlashLight extends Activity { /** Called when the activity is first created. */ public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); } } |
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 asavedInstanceState
. Don't be concerned with this bundle for our purposes; it is used when an activity is suspended and then resumed. - The
onCreate
method is an override of the activity class method of the same name. It calls the super class'sonCreate
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 R.java source file. Never edit this file directly, as it is changed upon every build.
Figure 6. White screen of flashlight
The AndroidManifest.xml file setup for the FlashLight application is shown below.
Listing 4. AndroidManifest.xml for FlashLight
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 outage.
In this article, you learned about Android at a very high level and built a small application. Hopefully, the example got you excited enough to explore more of the Android platform. Android promises to be a market-moving open source platform that will be useful well beyond cell phones.
Description | Name | Size | Download method |
---|---|---|---|
FlashLight source code | os-android-devel-FlashLight.zip | 22KB | HTTP |
Resources
Learn
-
The Open Handset
Alliance is a group of 47 technology and mobile
companies who have come together to
accelerate innovation in mobile and offer consumers a
richer, less
expensive, and better mobile experience. Together, they
have developed Android, the first complete, open, and free mobile
platform.
-
The Android developers site offers
documentation, downloads, blogs, and more.
-
Learn more about the Dalvik Virtual
Machine.
-
Check out the tutorials
hosted on YouTube that discuss the internals of the Dalvik VM.
-
Unlocking Android: A Developer's
Guide provides concise, hands-on instruction for the Android operating system and development tools.
-
To listen to interesting interviews and discussions for software developers, check out developerWorks podcasts.
-
Stay current with developerWorks' Technical events and webcasts.
-
Follow developerWorks on Twitter.
-
Check out upcoming conferences, trade shows, webcasts, and other Events around the world that are of interest to IBM open source developers.
-
Visit the developerWorks Open source zone
for extensive how-to information, tools, and project updates to help
you develop with open source technologies and use them with IBM's
products.
-
Watch and learn about IBM and open source technologies and product functions with the no-cost developerWorks On demand demos.
-
Download the Android SDK.
-
Get the latest Eclipse IDE.
-
Innovate your next open source development project with IBM trial software, available for download or on DVD.
- Download
IBM product evaluation versions
or explore
the online trials in the IBM SOA Sandbox and get
your hands on application development tools and middleware products
from DB2®, Lotus®, Rational®, Tivoli®, and WebSphere®.
-
Participate in developerWorks blogs and get involved in the developerWorks community.