Android an open handset alliance project

Android™ delivers a complete set of software for mobile devices: an operating system, middleware and key mobile applications. The Android Software Development Kit (SDK) is now available. 

Android was built from the ground-up to enable developers to create compelling mobile applications that take full advantage of all a handset has to offer. It was built to be truly open. For example, an application can call upon any of the phone's core functionality such as making calls, sending text messages, or using the camera, allowing developers to create richer and more cohesive experiences for users. Android is built on the open Linux Kernel. Furthermore, it utilizes a custom virtual machine that was designed to optimize memory and hardware resources in a mobile environment. Android is open source; it can be liberally extended to incorporate new cutting edge technologies as they emerge. The platform will continue to evolve as the developer community works together to build innovative mobile applications. 

All applications are created equal 

Android does not differentiate between the phone's core applications and third-party applications. They can all be built to have equal access to a phone's capabilities providing users with a broad spectrum of applications and services. With devices built on the Android Platform, users are able to fully tailor the phone to their interests. They can swap out the phone's homescreen, the style of the dialer, or any of the applications. They can even instruct their phones to use their favorite photo viewing application to handle the viewing of all photos. 

Android breaks down the barriers to building new and innovative applications. For example, a developer can combine information from the web with data on an individual's mobile phone -- such as the user's contacts, calendar, or geographic location -- to provide a more relevant user experience. With Android, a developer can build an application that enables users to view the location of their friends and be alerted when they are in the vicinity giving them a chance to connect. 

Fast & easy application development 

Android provides access to a wide range of useful libraries and tools that can be used to build rich applications. For example, Android enables developers to obtain the location of the device, and allows devices to communicate with one another enabling rich peer-to-peer social applications. In addition, Android includes a full set of tools that have been built from the ground up alongside the platform providing developers with high productivity and deep insight into their applications. 

Android is an application framework on top of Linux. It is supplied as open source code, but does not bind the user with the constraints of the GPL " there is no requirement for developers to make public any code developed using Android. 

Android Architecture 

An Android system consists essentially of five software layers: 

The Android platform is a Linux 2.6 kernel, a custom-made Java Virtual Machine called Dalvik, and a set of Java classes specially tailored for mobile use. The Google pages devoted to Android have lots of technical details. One important thing to understand is that all Android applications are in Java, and they all run as separate Linux processes. The Android system assigns each process a unique Linux user ID; this is the basis of the Android security model.

You need to download the Android SDK as the first step.

Google recommends using the SDK as an Eclipse plugin. We found little value in doing that. We are mainly a NetBeans shop. We found that the easiest way to get started is simply to use the command-line tools.

And the tool to use is activityCreator.py, which creates an Activity. An Activity corresponds roughly to a "screen". You're building an application, which normally consists of a few Activitys. Applications can have other components, such as Services, but we'll start withActivitys.

activityCreator --out /home/me/MyApplication \

chiralsoftware.androidapp.MainActivity

This creates an activity called MainActivity in the chiralsoftware.androidapp package, in the /home/me/MyApplication directory. It also creates a helpful build.xml file.

The package is complete and ready to run. Let's try it out before making any changes.

Start the emulator. No arguments are needed:

emulator

Build the app:

% ant

Buildfile: build.xml

[mkdir] Created dir: /tmp/droid/bin/classes

[echo] Generating R.java...

[javac] Compiling 2 source files to /tmp/droid/bin/classes

[echo] Packaging resources...

[echo] Packaging dex...

Total time: 3 seconds

This creates a file called bin/MainActivity.apk. Normal Java applications are shipped as Java Archive (JAR) files, which are essential ZIP files containing Java class files. Android applications instead use a .apk file, which is also a ZIP archive, but with a different format from a JAR file. In particular, a APK file does not have a META-INF or a MANIFEST.MF. It does have an AndroidManifest.xml file. It looks like this:

jar tf bin/MainActivity.apk

res/layout/main.xml

AndroidManifest.xml

resources.arsc

classes.dex

Where are the classes? They are in the classes.dex file. This is a special binary file format which wraps a set of ordinary Java classes.

AndroidManifest.xml seems like it would be a simple copy of the AndroidManifest.xml that's in the application source directory. It isn't. It's some binary format, which presumably contains the same information in a format which is quicker for Android to process.

With the emulator running, use the adb tool to copy the MainActivity.apk file over into the emulator's virtual memory:

adb install bin/MainActivity.apk

45 KB/s (4130 bytes in 0.088s)

adb can connect to the emulator because the emulator listens on certain TCP ports which adb knows.

Click "all" on the emulator and the activity shows up:

Click on the app to run it, and you'll see the Hello World message.

The easier way to do all this is to run the emulator, and then use the build.xml script:

ant clean install

That does it all.

Getting work done

The main functionality you'll use is the Activity.

You can lay out the display using code, but this is not recommended. Instead, it is best to create the layout in a separate layout XML file. This layout file creates UI components with IDs. In this case, the layout file is in res/layout/main.xml. We can put assign the objects IDs in the layout file like this:


android:id="@+id/password"

android:layout_width="164px"

android:layout_height="wrap_content"

android:padding="10px"

android:textSize="18sp"

android:password="true"

>

Then, the build.xml file's resource-src task uses the aapt program to generate a file called R.java. R contains references to all the objects with IDs in the layout file, so in R we have:

public final class R {
public static final class id {

public static final int password=0x7f04000a;

Now, within the activity, we can get the password field and read text from it as follows:

final EditText passwordField = (EditText) findViewById(R.id.password);

String password = passwordField.getText().toString();

It's different from how we think of Swing or web layouts. It's also better. Layout should not be in code. Swing and other systems are moving in this same direction.

Hand-coding the necessary layout files is a pain. The best way to do it is to use a visual design tool. That tool is DroidDraw, Android's answer to NetBeans' Matisse. Download and run the DroidDraw JAR, and try some layout.

Remember to go to the Properties tab of the layout components to give them an ID which you can refer to using the R class.

Save the file directly into the res/layout directory.

Debugging

Do make use of the logging class, like this:

import android.util.Log;
Log.i("LogTag", "This is a log message", exception);

When the Log.i method is called, a log message is generated. You can view logs easily with the adb logcat command:

I/DEBUG ( 494): debuggerd: Feb 28 2008 17:13:08

D/AndroidRuntime( 496):

D/AndroidRuntime( 496): AndroidRuntime START

I/AndroidRuntime( 496): Assertions enabled for ALL code (-ea and -esa)

I/runtime ( 497): Startup: sys='/system' asset='/system/app' data='/data'

I/runtime ( 497): Entered boot_init()!

D/runtime ( 497): ProcessState: 0x124e8

I/runtime ( 497): Binder driver opened. Multiprocess enabled.

D/AndroidRuntime( 496): --- registering native functions ---

Log messages will show up in this stream.

Conclusion

Developing with Android is a pleasure. We're confident that Android will be a major platform in the near future, and we're looking forward to continuing to develop for it.

Future articles will discuss how to use Activitys, including adding them to the AndroidManifest.xml file, and calling one Activity from another. We'll also discuss our favorite topic, which is client-server. With the right class libraries, it's not difficult to use SOAP for client-server interactions. We'll demonstrate Android using SOAP to communicate with JBoss Seam web services.

If your business needs to kick start its Android development to have products ready when the first Android handsets hit the stores for this year's gift season, contact us at 310 356 7869, or at sales@chiralsoftware.net, and we can discuss getting your Android project started.