Building the SaySomething Android application

This section creates a basic Android application, called SaySomething, using the Android Developer Tools. Once the application is created, we will debug and run it.

New project wizard

The first step is to create a new project. Select the wizard for Android project, as shown below.

The requirements for the application are:

• Name
• Location
• Package name
• Activity name — Think of this as the main "form" or screen of the application
• Application name

Take a look at the new project.

This will create a default application ready to be built and run. The components may be seen in the Package Explorer, which we discuss next.

Back to top

The Package Explorer

The Package Explorer (found in the Java perspective in Eclipse) displays all the components of the sample Android application (see Figure 4).

Items of note include:

src folder

Includes the package for the sample application, namely com.msi.ibmtutorial

R.java

The Android Developer Tools create this file automatically and represents the constants needed to access various resources of the Android application. More on the relationship between the R class and resources is found below.

SaySomething.java

Implementation of the application's primary activity class.

Referenced libraries

Contains android.jar, which is the Android runtime class jar file, found in the Android SDK.

res folder

Contains the resources for the application, including:

• Icons
• Layout files
• Strings

AndriodManifest.xml

Deployment descriptor of the sample application.

Next, we'll examine the source code in further detail.

Back to top

The primary activity of the application

The sample application consists of a single activity, namely SaySomething. As described above, the SaySomething class is implemented in the file SaySomething.java.

                    
package com.msi.ibmtutorial;

import android.app.Activity;
import android.os.Bundle;

public class SaySomething extends Activity 
{
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle icicle) 
   {
        super.onCreate(icicle);
        setContentView(R.layout.main);
    }
}

Things to note about this source snippet:

• SaySomething is a normal Java class, with a package and imports, as expected.
• SaySomething extends a base Android class named Activity, which is located in the android.app package.
• The onCreate() method is the entry point to this activity, receiving an argument of type Bundle. The Bundle is a class which is essentially a wrapper around a map or hashmap. Elements required for construction are passed in this parameter. This tutorial does not examine this parameter.
• The setContentView(..) is responsible for creating the primary UI using the R.layout.main argument. This is an identifier representing the main layout found in the resources of the application.

The next section reviews the resources for the sample application.

Back to top

Resources for the application

Resources in Android are organized into a subdirectory of the project named res, as described previously. Resources fall into three primary categories:

Drawables

This folder contains graphics files, such as icons and bitmaps

Layouts

This folder contains XML files that represent the layouts and views of the application. These will be examined in detail below.

Values

This folder contains a file named strings.xml. This is the primary means for string localization for the application.

The next section dissects the main.xml file to review the sample application's primary UI resources.

Back to top

main.xml

The sample application contains a single activity and a single view. The application contains a file named main.xml that represents the visual aspects of the primary UI of the activity. Note that there is no reference in the main.xml where the layout is used. This means it may be used in more than one activity, if desired. Listing 5 contains the content of the layout file.

                    
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    >
<TextView  
    android:layout_width="fill_parent" 
    android:layout_height="wrap_content" 
    android:text="Hello World, SaySomething"
    />
</LinearLayout>

This is the most simplistic of layouts. There is a single linear layout, which is oriented as a vertical layout, meaning all contained elements are in a single column. There is a single TextView element, which can be likened to a label in other development environments. A TextView represents static text that is not editable.

Note that each view element (layout and TextView in this example) have attributes in the Android name space. Some attributes are common to all views — the android:layout_width and android:layout_height attributes, for example. The values available for these attributes are:

Fill Parent

This extends the view element to take the maximum space available. This can also be thought of as meaning "stretch."

Wrap Content

This value tells Android to paint the elements one after the next without stretching.

During the build process, all resources are compiled. One of the products of that process is the R.java file, which represents the resources to the remainder of the application. The R.java file is discussed next.

Back to top

R.java

The R.java file is created upon build automatically, so be sure to not modify it by hand as all changes will be lost. Listing 6 contains the R.java file for the sample application.

                    
/* AUTO-GENERATED FILE.  DO NOT MODIFY.
 *
 * This class was automatically generated by the
 * aapt tool from the resource data it found.  It
 * should not be modified by hand.
 */

package com.msi.ibmtutorial;

public final class R {
    public static final class attr {
    }
    public static final class drawable {
        public static final int icon=0x7f020000;
    }
    public static final class layout {
        public static final int main=0x7f030000;
    }
    public static final class string {
        public static final int app_name=0x7f040000;
    }
}

The R class contains anonymous subclasses, which each contain identifiers for the various resources previously described. Note that all of these classes are static.

Note the element represented by: R.layout.main. This identifier represents the layout defined by main.xml. Recall that this value is used in the onCreate method of the activity as follows: setContentView(R.layout.main);. This is the point at which a specific activity (in this case, SayAnything) and a specific layout (main) are bound together at runtime.

Back to top

Building applications

Files are compiled every time they are saved by default.

We introduced an error into the source code where we added an extra space between setContent and View. When the file is saved, it is compiled and any errors appear in the Problems pane at the bottom of the screen. Upon fixing the error in the source code, the application builds properly and the errors are removed from the problems list.

Back to top

AndroidManifest.xml

The AndroidManifest.xml file represents the deployment descriptor for an Android application. The file lists any activity, service, content provider, or receiver contained in the application, along with the appropriate IntentFilters supported by the application. Here is the complete AndroidManifest.xml file for the sample application:

                    
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.msi.ibmtutorial">
    <application android:icon="@drawable/icon">
        <activity class=".SaySomething" android:label="@string/app_name">
            <intent-filter>
                <action android:value="android.intent.action.MAIN" />
                <category android:value="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>
</manifest>

Things to note:

• The package name from the source file is represented here. This follows a similar pattern to a Java source file and imports. The <manifest> tag is in essence "importing" classes from this package. All non-fully qualified classes in this file are found in the package identified in the package attribute.
• The <application> tag has an attribute that references a resource from the application's resources. Note the @ symbol preceding the drawable identifier. This is a hint for the file to look in the drawable folder of the application's resources for a resource called "icon."
• The <activity> tag contains the following attributes and values of note:
  
  • class represents the Java class implementing this activity
  • android:label is the name of the application. Note that it is coming from one of the string resources. The string.xml file contains localized strings for the application.
  • <intent-filter> represents the IntentFilter available in the sample application. This is the most common IntentFilter seen in Android applications. This filter essentially says that it implements the "main" action (or entry point) and is located in the launcher of the OS. In English, this means it can be started as an application from the primary list of applications on an Android device.

The next section describes starting the application on the Android Emulator from within Eclipse.

Back to top

Running the application

Now that the application has compiled successfully, it's time to run the sample application. Select Open Run Dialog or shortcut on the toolbar within Eclipse. This opens a dialog where startup configurations are created. Highlight the Android Application option and click the icon for New.

Figure 6 show the values used for the tutorial sample.

Give the configuration a name. The tutorial sample uses the name Tutorial Configuration. Select the ibmtutorial project from the list of available projects (click Browse to see available projects). Select the startup activity in the drop-down. Now select the Emulator tab to specify Emulator settings, as desired. The default can be left alone. There are a couple of items to note, as described in Figure 7.

There are a few screen sizes and orientations to choose from, as well as network choices. The network choices are important when building applications that employ Internet connectivity as mobile devices have varying network speed capabilities. Choose full network speed and no latency when prototyping an application. Once the main functionality is present, it's a good idea to test with less-than-ideal network conditions to see how the application responds in situations with suboptimal network connectivity.

Select Run to see the sample application in action.

Now that the application is running on the Emulator, it's time to see what's happening behind the scenes. The Dalvik Debug Monitor Service (DDMS) will assist with this.

Back to top

Debugging the application

To see what is happening with a running application, it is helpful to tap into the running Dalvik VM. To enable this from Eclipse, select Window > Open Perspective > Other. This displays a dialog box where the DDMS may be selected. This opens a new perspective in Eclipse with a number of interesting windows. Here is a quick introduction to the available resources in the DDMS perspective:

The LogCat is a running log file of activity taking place in the VM. Applications can make their own entries to this list with a simple line of code as follows: Log.i(tag,message);, where tag and message are both Java strings. The Log class is part of the android.util.Log package.

Figure 9 shows the LogCat in action.

Another handy tool in the DDMS is the file explorer, which permits file system access of the Emulator. Figure 10 shows where the tutorial's sample application is deployed on the Emulator.

User applications are deployed in /data/app while Android built-in applications are found in the /system/app directory.

A running process list is also available in the DDMS.

Full-scale debugging of an Android application is beyond the scope of this tutorial. For more information, see Resources.

5 of 10 | Previous | Next

Comments

Back to top

Table of contents

• Before you start
• Introduction to Android
• Android applications — A quick survey
• Android Software Developer Kit
• Building the SaySomething Android application
• Building the content provider and Google Maps example
• Summary
• Download
• Resources
• About the author

---

5 of 10 | Previous | Next

Local resources

• IBM Innovation Center - Austin, TX
• IBM Innovation Center - Chicago, IL
• IBM Innovation Center - Dallas, TX
• IBM Innovation Center - San Mateo, CA
• IBM Innovation Center - Waltham, MA
• Technical Briefings in North America

Dig deeper into Open source on developerWorks

Try IBM PureSystems. No charge.

Experience today!

---

Get started with the cloud-based trial and pattern development kit.