Building Your First Android App

Welcome to Android application development!

This class teaches you how to build your first Android app. Youll learn how to create an Android project and run
a debuggable version of the app. You'll also learn some fundamentals of Android app design, including how to
build a simple user interface and handle user input.
Before you start this class, be sure you have your development environment set up. You need to:
1. Download the Android SDK.
2. Install the ADT plugin for Eclipse (if youll use the Eclipse IDE).
3. Download the latest SDK tools and platforms using the SDK Manager.
Note: Make sure you install the most recent versions of the ADT plugin and the Android SDK before you start
this class. The procedures described in this class may not apply to earlier versions.
If you haven't already done these tasks, start by downloading the Android SDK and following the install steps.
Once you've finished the setup, you're ready to begin this class.
This class uses a tutorial format that incrementally builds a small Android app that teaches you some
fundamental concepts about Android development, so it's important that you follow each step.
Creating an Android Project

An Android project contains all the files that comprise the source code for your Android app. The Android SDK
tools make it easy to start a new Android project with a set of default project directories and files.
This lesson shows how to create a new project either using Eclipse (with the ADT plugin) or using the SDK tools
from a command line.
Note: You should already have the Android SDK installed, and if you're using Eclipse, you should also have
the ADT plugininstalled (version 22.6.2 or higher). If you don't have these, follow the guide to Installing the
Android SDK before you start this lesson.
Create a Project with Eclipse

1. Click New in the toolbar.
2. In the window that appears, open the Android folder, select Android Application Project, and click Next.

Figure 1. The New Android App Project wizard in Eclipse.
3. Fill in the form that appears:
o Application Name is the app name that appears to users. For this project, use "My First App."
o Project Name is the name of your project directory and the name visible in Eclipse.
o Package Name is the package namespace for your app (following the same rules as packages in the J ava
programming language). Your package name must be unique across all packages installed on the Android
system. For this reason, it's generally best if you use a name that begins with the reverse domain name of
your organization or publisher entity. For this project, you can use something like
"com.example.myfirstapp." However, you cannot publish your app on Google Play using the
"com.example" namespace.
o Minimum Required SDK is the lowest version of Android that your app supports, indicated using the API
level. To support as many devices as possible, you should set this to the lowest version available that
allows your app to provide its core feature set. If any feature of your app is possible only on newer versions
of Android and it's not critical to the app's core feature set, you can enable the feature only when running
on the versions that support it (as discussed in Supporting Different Platform Versions). Leave this set to
the default value for this project.
o Target SDK indicates the highest version of Android (also using the API level) with which you have tested
with your application.
As new versions of Android become available, you should test your app on the new version and update
this value to match the latest API level in order to take advantage of new platform features.
o Compile With is the platform version against which you will compile your app. By default, this is set to the
latest version of Android available in your SDK. (It should be Android 4.1 or greater; if you don't have such
a version available, you must install one using the SDK Manager). You can still build your app to support
older versions, but setting the build target to the latest version allows you to enable new features and
optimize your app for a great user experience on the latest devices.
o Theme specifies the Android UI style to apply for your app. You can leave this alone.
Click Next.
4. On the next screen to configure the project, leave the default selections and click Next.
5. The next screen can help you create a launcher icon for your app.
You can customize an icon in several ways and the tool generates an icon for all screen densities. Before you
publish your app, you should be sure your icon meets the specifications defined in the Iconography design
guide.
Click Next.
6. Now you can select an activity template from which to begin building your app.
For this project, select BlankActivity and click Next.
7. Leave all the details for the activity in their default state and click Finish.
Your Android project is now a basic "Hello World" app that contains some default files. To run the app, continue
to the next lesson.
Create a Project with Command Line Tools

If you're not using the Eclipse IDE with the ADT plugin, you can instead create your project using the SDK tools
from a command line:
1. Change directories into the Android SDKs t ool s/ path.
2. Execute:
andr oi d l i st t ar get s
This prints a list of the available Android platforms that youve downloaded for your SDK. Find the platform
against which you want to compile your app. Make a note of the target id. We recommend that you select the
highest version possible. You can still build your app to support older versions, but setting the build target to
the latest version allows you to optimize your app for the latest devices.
If you don't see any targets listed, you need to install some using the Android SDK Manager tool. See Adding
Platforms and Packages.
3. Execute:
4. andr oi d cr eat e pr oj ect - - t ar get <t ar get - i d> - - name MyFi r st App \
5. - - pat h <pat h- t o- wor kspace>/ MyFi r st App - - act i vi t y Mai nAct i vi t y \
6. - - package com. exampl e. myf i r st app
Replace <t ar get - i d>with an id from the list of targets (from the previous step) and replace <pat h- t o-
wor kspace>with the location in which you want to save your Android projects.
Your Android project is now a basic "Hello World" app that contains some default files. To run the app, continue
to the next lesson.
Tip: Add the pl at f or m- t ool s/ as well as the t ool s/ directory to your PATH environment variable.
Running Your App

If you followed the previous lesson to create an Android project, it includes a default set of "Hello World" source
files that allow you to immediately run the app.
How you run your app depends on two things: whether you have a real Android-powered device and whether
you're using Eclipse. This lesson shows you how to install and run your app on a real device and on the Android
emulator, and in both cases with either Eclipse or the command line tools.
Before you run your app, you should be aware of a few directories and files in the Android project:
Andr oi dMani f est . xml
The manifest file describes the fundamental characteristics of the app and defines each of its
components. You'll learn about various declarations in this file as you read more training classes.
One of the most important elements your manifest should include is the <uses- sdk>element. This
declares your app's compatibility with different Android versions using
the andr oi d: mi nSdkVer si on andandr oi d: t ar get SdkVer si on attributes. For your first app, it should
look like this:
<mani f est xml ns: andr oi d=" ht t p: / / schemas. andr oi d. com/ apk/ r es/ andr oi d" . . . >
<uses- sdk andr oi d: mi nSdkVer si on=" 8" andr oi d: t ar get SdkVer si on=" 19" / >
. . .
</ mani f est >
You should always set the andr oi d: t ar get SdkVer si on as high as possible and test your app on the
corresponding platform version. For more information, read Supporting Different Platform Versions.
sr c/
Directory for your app's main source files. By default, it includes an Act i vi t y class that runs when your
app is launched using the app icon.
r es/
Contains several sub-directories for app resources. Here are just a few:
dr awabl e- hdpi /
Directory for drawable objects (such as bitmaps) that are designed for high-density (hdpi) screens. Other
drawable directories contain assets designed for other screen densities.
l ayout /
Directory for files that define your app's user interface.
val ues/
Directory for other various XML files that contain a collection of resources, such as string and color
definitions.
When you build and run the default Android app, the default Act i vi t y class starts and loads a
layout file that says "Hello World." The result is nothing exciting, but it's important that you
understand how to run your app before you start developing.
Run on a Real Device

If you have a real Android-powered device, here's how you can install and run your app:
1. Plug in your device to your development machine with a USB cable. If you're developing on
Windows, you might need to install the appropriate USB driver for your device. For help
installing drivers, see the OEM USB Drivers document.
2. Enable USB debugging on your device.
o On most devices running Android 3.2 or older, you can find the option under Settings >
Applications > Development.
o On Android 4.0 and newer, it's in Settings > Developer options.
Note: On Android 4.2 and newer, Developer options is hidden by default. To make it
available, go toSettings > About phone and tap Build number seven times. Return to the
previous screen to findDeveloper options.
To run the app from Eclipse:
1. Open one of your project's files and click Run from the toolbar.
2. In the Run as window that appears, select Android Application and click OK.
Eclipse installs the app on your connected device and starts it.
Or to run your app from a command line:
1. Change directories to the root of your Android project and execute:
ant debug
2. Make sure the Android SDK pl at f or m- t ool s/ directory is included in your PATH environment
variable, then execute:
adb i nst al l bi n/ MyFi r st App- debug. apk
3. On your device, locate MyFirstActivity and open it.
That's how you build and run your Android app on a device! To start developing, continue to
the next lesson.
Run on the Emulator

Whether you're using Eclipse or the command line, to run your app on the emulator you need to
first create anAndroid Virtual Device (AVD). An AVD is a device configuration for the Android
emulator that allows you to model different devices.

Figure 1. The AVD Manager showing a few virtual devices.
To create an AVD:
1. Launch the Android Virtual Device Manager:
a. In Eclipse, click Android Virtual Device Manager from the toolbar.
b. From the command line, change directories to<sdk>/ t ool s/ and execute:
andr oi d avd
2. In the Android Virtual Device Manager panel, click New.
3. Fill in the details for the AVD. Give it a name, a platform target, an SD card size, and a skin
(HVGA is default).
4. Click Create AVD.
5. Select the new AVD from the Android Virtual Device Manager and click Start.
6. After the emulator boots up, unlock the emulator screen.
To run the app from Eclipse:
1. Open one of your project's files and click Run from the toolbar.
2. In the Run as window that appears, select Android Application and click OK.
Eclipse installs the app on your AVD and starts it.
Or to run your app from the command line:
1. Change directories to the root of your Android project and execute:
ant debug
2. Make sure the Android SDK pl at f or m- t ool s/ directory is included in your PATH environment
variable, then execute:
adb i nst al l bi n/ MyFi r st App- debug. apk
3. On the emulator, locate MyFirstActivity and open it.
That's how you build and run your Android app on the emulator! To start developing, continue to
the next lesson.
Building a Simple User Interface

The graphical user interface for an Android app is built using a hierarchy
of Vi ew and Vi ewGr oup objects. Vi ew objects are usually UI widgets such as buttons or text
fields andVi ewGr oup objects are invisible view containers that define how the child views are laid out, such as in
a grid or a vertical list.
Android provides an XML vocabulary that corresponds to the subclasses of Vi ew and Vi ewGr oup so you can
define your UI in XML using a hierarchy of UI elements.
Alternative Layouts
Declaring your UI layout in XML rather than runtime code is useful for several reasons, but it's especially important so
you can create different layouts for different screen sizes. For example, you can create two versions of a layout and
tell the system to use one on "small" screens and the other on "large" screens. For more information, see the class
about Supporting Different Devices.

Figure 1. Illustration of how Vi ewGr oup objects form branches in the layout and contain other Vi ew objects.
In this lesson, you'll create a layout in XML that includes a text field and a button. In the following lesson, you'll
respond when the button is pressed by sending the content of the text field to another activity.
Create a Linear Layout

Open the f r agment _mai n. xml file from the r es/ l ayout / directory.
Note: In Eclipse, when you open a layout file, youre first shown the Graphical Layout editor. This is an editor
that helps you build layouts using WYSIWYG tools. For this lesson, youre going to work directly with the XML,
so click the fragment_main.xml tab at the bottom of the screen to open the XML editor.
The BlankActivity template you chose when you created this project includes the f r agment _mai n. xml file with
a Rel at i veLayout root view and a Text Vi ew child view.
First, delete the <Text Vi ew>element and change the <Rel at i veLayout >element to <Li near Layout >. Then
add the andr oi d: or i ent at i on attribute and set it to " hor i zont al ". The result looks like this:
<Li near Layout xml ns: andr oi d=" ht t p: / / schemas. andr oi d. com/ apk/ r es/ andr oi d"
xml ns: t ool s=" ht t p: / / schemas. andr oi d. com/ t ool s"
andr oi d: l ayout _wi dt h=" mat ch_par ent "
andr oi d: l ayout _hei ght =" mat ch_par ent "
andr oi d: or i ent at i on=" hor i zont al " >
</ Li near Layout >
Li near Layout is a view group (a subclass of Vi ewGr oup) that lays out child views in either a vertical or
horizontal orientation, as specified by the andr oi d: or i ent at i on attribute. Each child of
a Li near Layout appears on the screen in the order in which it appears in the XML.
The other two attributes, andr oi d: l ayout _wi dt h and andr oi d: l ayout _hei ght , are required for all views in
order to specify their size.
Because the Li near Layout is the root view in the layout, it should fill the entire screen area that's available to
the app by setting the width and height to " mat ch_par ent ". This value declares that the view should expand its
width or height to match the width or height of the parent view.
For more information about layout properties, see the Layout guide.
Add a Text Field

To create a user-editable text field, add an <Edi t Text >element inside the <Li near Layout >.
Like every Vi ew object, you must define certain XML attributes to specify the Edi t Text object's properties.
Heres how you should declare it inside the <Li near Layout >element:
<Edi t Text andr oi d: i d=" @+i d/ edi t _message"
andr oi d: l ayout _wi dt h=" wr ap_cont ent "
andr oi d: l ayout _hei ght =" wr ap_cont ent "
andr oi d: hi nt =" @st r i ng/ edi t _message" / >
About resource objects
A resource object is simply a unique integer name that's associated with an app resource, such as a bitmap, layout
file, or string.
Every resource has a corresponding resource object defined in your project's gen/ R. j ava file. You can use the
object names in the R class to refer to your resources, such as when you need to specify a string value for
the andr oi d: hi nt attribute. You can also create arbitrary resource IDs that you associate with a view using
theandr oi d: i d attribute, which allows you to reference that view from other code.
The SDK tools generate the R. j avaeach time you compile your app. You should never modify this file by hand.
For more information, read the guide toProviding Resources.
About these attributes:
andr oi d: i d
This provides a unique identifier for the view, which you can use to reference the object from your app
code, such as to read and manipulate the object (you'll see this in the next lesson).
The at sign (@) is required when you're referring to any resource object from XML. It is followed by the
resource type (i d in this case), a slash, then the resource name (edi t _message).
The plus sign (+) before the resource type is needed only when you're defining a resource ID for the first
time. When you compile the app, the SDK tools use the ID name to create a new resource ID in your
project's gen/ R. j ava file that refers to the Edi t Text element. Once the resource ID is declared once
this way, other references to the ID do not need the plus sign. Using the plus sign is necessary only
when specifying a new resource ID and not needed for concrete resources such as strings or layouts.
See the sidebox for more information about resource objects.
andr oi d: l ayout _wi dt h and andr oi d: l ayout _hei ght
Instead of using specific sizes for the width and height, the" wr ap_cont ent " value specifies that the
view should be only as big as needed to fit the contents of the view. If you were to instead
use " mat ch_par ent ", then theEdi t Text element would fill the screen, because it would match the size
of the parent Li near Layout . For more information, see the Layouts guide.
andr oi d: hi nt
This is a default string to display when the text field is empty. Instead of using a hard-coded string as the
value, the " @st r i ng/ edi t _message" value refers to a string resource defined in a separate file.
Because this refers to a concrete resource (not just an identifier), it does not need the plus sign.
However, because you haven't defined the string resource yet, youll see a compiler error at first. You'll
fix this in the next section by defining the string.
Note: This string resource has the same name as the element ID: edi t _message. However, references
to resources are always scoped by the resource type (such as i d or st r i ng), so using the same name
does not cause collisions.
Add String Resources

When you need to add text in the user interface, you should always specify each string as a
resource. String resources allow you to manage all UI text in a single location, which makes it
easier to find and update text. Externalizing the strings also allows you to localize your app to
different languages by providing alternative definitions for each string resource.
By default, your Android project includes a string resource file at r es/ val ues/ st r i ngs. xml .
Add a new string named " edi t _message" and set the value to "Enter a message." (You can
delete the "hello_world" string.)
While youre in this file, also add a "Send" string for the button youll soon add,
called " but t on_send".
The result for st r i ngs. xml looks like this:
<?xml ver si on=" 1. 0" encodi ng=" ut f - 8" ?>
<r esour ces>
<st r i ng name=" app_name" >My Fi r st App</ st r i ng>
<st r i ng name=" edi t _message" >Ent er a message</ st r i ng>
<st r i ng name=" but t on_send" >Send</ st r i ng>
<st r i ng name=" act i on_set t i ngs" >Set t i ngs</ st r i ng>
<st r i ng name=" t i t l e_act i vi t y_mai n" >Mai nAct i vi t y</ st r i ng>
</ r esour ces>
For more information about using string resources to localize your app for other languages, see
the Supporting Different Devices class.
Add a Button

Now add a <But t on>to the layout, immediately following the <Edi t Text >element:
<But t on
andr oi d: l ayout _wi dt h=" wr ap_cont ent "
andr oi d: l ayout _hei ght =" wr ap_cont ent "
andr oi d: t ext =" @st r i ng/ but t on_send" / >
The height and width are set to " wr ap_cont ent " so the button is only as big as necessary to fit
the button's text. This button doesn't need the andr oi d: i d attribute, because it won't be
referenced from the activity code.
Make the Input Box Fill in the Screen Width

The layout is currently designed so that both the Edi t Text and But t on widgets are only as big
as necessary to fit their content, as shown in figure 2.

Figure 2. The Edi t Text and But t on widgets have their widths set to " wr ap_cont ent " .
This works fine for the button, but not as well for the text field, because the user might type
something longer. So, it would be nice to fill the unused screen width with the text field. You can
do this inside a Li near Layout with the weight property, which you can specify using
the andr oi d: l ayout _wei ght attribute.
The weight value is a number that specifies the amount of remaining space each view should
consume, relative to the amount consumed by sibling views. This works kind of like the amount of
ingredients in a drink recipe: "2 parts vodka, 1 part coffee liqueur" means two-thirds of the drink is
vodka. For example, if you give one view a weight of 2 and another one a weight of 1, the sum is
3, so the first view fills 2/3 of the remaining space and the second view fills the rest. If you add a
third view and give it a weight of 1, then the first view (with weight of 2) now gets 1/2 the
remaining space, while the remaining two each get 1/4.
The default weight for all views is 0, so if you specify any weight value greater than 0 to only one
view, then that view fills whatever space remains after all views are given the space they require.
So, to fill the remaining space in your layout with the Edi t Text element, give it a weight of 1 and
leave the button with no weight.
<Edi t Text
andr oi d: l ayout _wei ght =" 1"
. . . / >
In order to improve the layout efficiency when you specify the weight, you should change the
width of theEdi t Text to be zero (0dp). Setting the width to zero improves layout performance
because using" wr ap_cont ent " as the width requires the system to calculate a width that is
ultimately irrelevant because the weight value requires another width calculation to fill the
remaining space.
<Edi t Text
andr oi d: l ayout _wei ght =" 1"
andr oi d: l ayout _wi dt h=" 0dp"
. . . / >
Figure 3 shows the result when you assign all weight to the Edi t Text element.

Figure 3. The Edi t Text widget is given all the layout weight, so fills the remaining space in
the Li near Layout .
Heres how your complete layout file should now look:
<?xml ver si on=" 1. 0" encodi ng=" ut f - 8" ?>
<Li near Layout xml ns: andr oi d=" ht t p: / / schemas. andr oi d. com/ apk/ r es/ andr oi d"
xml ns: t ool s=" ht t p: / / schemas. andr oi d. com/ t ool s"
andr oi d: l ayout _wi dt h=" mat ch_par ent "
andr oi d: l ayout _hei ght =" mat ch_par ent "
andr oi d: or i ent at i on=" hor i zont al " >
<Edi t Text andr oi d: i d=" @+i d/ edi t _message"
andr oi d: l ayout _wei ght =" 1"
andr oi d: l ayout _wi dt h=" 0dp"
andr oi d: l ayout _hei ght =" wr ap_cont ent "
andr oi d: hi nt =" @st r i ng/ edi t _message" / >
<But t on
andr oi d: l ayout _wi dt h=" wr ap_cont ent "
andr oi d: l ayout _hei ght =" wr ap_cont ent "
andr oi d: t ext =" @st r i ng/ but t on_send" / >
</ Li near Layout >
This layout is applied by the default Act i vi t y class that the SDK tools generated when you
created the project, so you can now run the app to see the results:
In Eclipse, click Run from the toolbar.
Or from a command line, change directories to the root of your Android project and execute:
ant debug
adb i nst al l bi n/ MyFi r st App- debug. apk
Continue to the next lesson to learn how you can respond to button presses, read content from
the text field, start another activity, and more.
Starting Another Activity

After completing the previous lesson, you have an app that shows an activity (a single screen) with a text field
and a button. In this lesson, youll add some code to Mai nAct i vi t ythat starts a new activity when the user
clicks the Send button.
Respond to the Send Button

To respond to the button's on-click event, open thef r agment _mai n. xml layout file and add
theandr oi d: onCl i ck attribute to the <But t on>element:
<But t on
andr oi d: l ayout _wi dt h=" wr ap_cont ent "
andr oi d: l ayout _hei ght =" wr ap_cont ent "
andr oi d: t ext =" @st r i ng/ but t on_send"
andr oi d: onCl i ck=" sendMessage" / >
The andr oi d: onCl i ck attributes value, " sendMessage", is the name of a method in your activity that the
system calls when the user clicks the button.
Open the Mai nAct i vi t y class (located in the project's sr c/ directory) and add the corresponding method:
/ ** Cal l ed when t he user cl i cks t he Send but t on */
publ i c voi d sendMessage( Vi ew vi ew) {
/ / Do somet hi ng i n r esponse t o but t on
}
In order for the system to match this method to the method name given to andr oi d: onCl i ck, the signature
must be exactly as shown. Specifically, the method must:
Be public
Have a void return value
Have a Vi ew as the only parameter (this will be the Vi ew that was clicked)
Next, youll fill in this method to read the contents of the text field and deliver that text to another activity.
Build an Intent

An I nt ent is an object that provides runtime binding between separate components (such as two activities).
The I nt ent represents an apps "intent to do something." You can use intents for a wide variety of tasks, but
most often theyre used to start another activity.
Inside the sendMessage( ) method, create an I nt ent to start an activity called Di spl ayMessageAct i vi t y:
I nt ent i nt ent = new I nt ent ( t hi s, Di spl ayMessageAct i vi t y. cl ass) ;
This requires that you import the I nt ent class:
i mpor t andr oi d. cont ent . I nt ent ;
Tip: In Eclipse, press Ctrl +Shift +O to import missing classes (Cmd +Shift +O on Mac).
The constructor used here takes two parameters:
A Cont ext as its first parameter (t hi s is used because the Act i vi t y class is a subclass of Cont ext )
The Cl ass of the app component to which the system should deliver the I nt ent (in this case, the activity that
should be started)
Sending an intent to other apps
The intent created in this lesson is what's considered an explicit intent, because the I nt ent specifies the exact app
component to which the intent should be given. However, intents can also be implicit, in which case the I nt ent does
not specify the desired component, but allows any app installed on the device to respond to the intent as long as it
satisfies the meta-data specifications for the action that's specified in various I nt ent parameters. For more
information, see the class about Interacting with Other Apps.
Note: The reference to Di spl ayMessageAct i vi t y will raise an error if youre using an IDE such as Eclipse
because the class doesnt exist yet. Ignore the error for now; youll create the class soon.
An intent not only allows you to start another activity, but it can carry a bundle of data to the activity as well.
Inside thesendMessage( ) method, use f i ndVi ewByI d( ) to get theEdi t Text element and add its text value to
the intent:
I nt ent i nt ent = new I nt ent ( t hi s, Di spl ayMessageAct i vi t y. cl ass) ;
Edi t Text edi t Text = ( Edi t Text ) f i ndVi ewByI d( R. i d. edi t _message) ;
St r i ng message = edi t Text . get Text ( ) . t oSt r i ng( ) ;
i nt ent . put Ext r a( EXTRA_MESSAGE, message) ;
Note: You now need an import statement forandr oi d. wi dget . Edi t Text . You'll define
the EXTRA_MESSAGE constant in a moment.
An I nt ent can carry a collection of various data types as key-value pairs called extras.
The put Ext r a( ) method takes the key name in the first parameter and the value in the second parameter.
In order for the next activity to query the extra data, you should define the key for your intent's extra using a
public constant. So add the EXTRA_MESSAGE definition to the top of the Mai nAct i vi t y class:
publ i c cl ass Mai nAct i vi t y ext ends Act i onBar Act i vi t y {
publ i c f i nal st at i c St r i ng EXTRA_MESSAGE = " com. exampl e. myf i r st app. MESSAGE" ;
. . .
}
It's generally a good practice to define keys for intent extras using your app's package name as a prefix. This
ensures they are unique, in case your app interacts with other apps.
Start the Second Activity

To start an activity, call st ar t Act i vi t y( ) and pass it your I nt ent . The system receives this call and starts an
instance of the Act i vi t y specified by the I nt ent .
With this new code, the complete sendMessage( ) method that's invoked by the Send button now looks like this:
/ ** Cal l ed when t he user cl i cks t he Send but t on */
publ i c voi d sendMessage( Vi ew vi ew) {
I nt ent i nt ent = new I nt ent ( t hi s, Di spl ayMessageAct i vi t y. cl ass) ;
Edi t Text edi t Text = ( Edi t Text ) f i ndVi ewByI d( R. i d. edi t _message) ;
St r i ng message = edi t Text . get Text ( ) . t oSt r i ng( ) ;
i nt ent . put Ext r a( EXTRA_MESSAGE, message) ;
st ar t Act i vi t y( i nt ent ) ;
}
Now you need to create the Di spl ayMessageAct i vi t y class in order for this to work.
Create the Second Activity


Figure 1. The new activity wizard in Eclipse.
To create a new activity using Eclipse:
1. Click New in the toolbar.
2. In the window that appears, open theAndroid folder and select Android Activity. Click Next.
3. Select BlankActivity and click Next.
4. Fill in the activity details:
o Project: MyFirstApp
o Activity Name: DisplayMessageActivity
o Layout Name: activity_display_message
o Fragment Layout Name: fragment_display_message
o Title: My Message
o Hierarchial Parent: com.example.myfirstapp.MainActivity
o Navigation Type: None
Click Finish.
If you're using a different IDE or the command line tools, create a new file
namedDi spl ayMessageAct i vi t y. j ava in the project's sr c/ directory, next to the
original Mai nAct i vi t y. j ava file.
Open the Di spl ayMessageAct i vi t y. j ava file. If you used Eclipse to create this activity:
The class already includes an implementation of the required onCr eat e( ) method. You will update the
implementation of this method later.
There's also an implementation of the onCr eat eOpt i onsMenu( ) method, but you won't need it for this app
so you can remove it.
There's also an implementation of onOpt i onsI t emSel ect ed( ) which handles the behavior for the action
bar's Up behavior. Keep this one the way it is.
There's also a Pl acehol der Fr agment class that extends Fr agment . You will not need this class in the final
version of this activity.
Fragments decompose application functionality and UI into reusable modules. For more information on
fragments, see the Fragments API Guide. The final version of this activity does not use fragments.
Note: Your activity may look different if you did not use the latest version of the ADT plugin. Make sure you
install the latest version of the ADT plugin to complete this tutorial.
The Di spl ayMessageAct i vi t y class should now look like this:
publ i c cl ass Di spl ayMessageAct i vi t y ext ends Act i onBar Act i vi t y {

@Over r i de
pr ot ect ed voi d onCr eat e( Bundl e savedI nst anceSt at e) {
super . onCr eat e( savedI nst anceSt at e) ;
set Cont ent Vi ew( R. l ayout . act i vi t y_di spl ay_message) ;

i f ( savedI nst anceSt at e == nul l ) {
get Suppor t Fr agment Manager ( ) . begi nTr ansact i on( )
. add( R. i d. cont ai ner , new Pl acehol der Fr agment ( ) ) . commi t ( ) ;
}
}

@Over r i de
publ i c bool ean onOpt i onsI t emSel ect ed( MenuI t emi t em) {
/ / Handl e act i on bar i t emcl i cks her e. The act i on bar wi l l
/ / aut omat i cal l y handl e cl i cks on t he Home/ Up but t on, so l ong
/ / as you speci f y a par ent act i vi t y i n Andr oi dMani f est . xml .
i nt i d = i t em. get I t emI d( ) ;
i f ( i d == R. i d. act i on_set t i ngs) {
r et ur n t r ue;
}
r et ur n super . onOpt i onsI t emSel ect ed( i t em) ;
}

/ **
* A pl acehol der f r agment cont ai ni ng a si mpl e vi ew.
*/
publ i c st at i c cl ass Pl acehol der Fr agment ext ends Fr agment {

publ i c Pl acehol der Fr agment ( ) { }

@Over r i de
publ i c Vi ew onCr eat eVi ew( Layout I nf l at er i nf l at er , Vi ewGr oup cont ai ner ,
Bundl e savedI nst anceSt at e) {
Vi ew r oot Vi ew = i nf l at er . i nf l at e( R. l ayout . f r agment _di spl ay_message,
cont ai ner , f al se) ;
r et ur n r oot Vi ew;
}
}
}
If you used an IDE other than Eclipse, update your Di spl ayMessageAct i vi t y class with the above code.
All subclasses of Act i vi t y must implement the onCr eat e( ) method. The system calls this when creating a
new instance of the activity. This method is where you must define the activity layout with
theset Cont ent Vi ew( ) method and is where you should perform initial setup for the activity components.
Note: If you are using an IDE other than Eclipse, your project does not contain
theact i vi t y_di spl ay_message layout that's requested by set Cont ent Vi ew( ) . That's OK because you will
update this method later and won't be using that layout.
Add the title string
If you used Eclipse, you can skip to the next section, because the template provides the title string for the new
activity.
If you're using an IDE other than Eclipse, add the new activity's title to the st r i ngs. xml file:
<r esour ces>
. . .
<st r i ng name=" t i t l e_act i vi t y_di spl ay_message" >My Message</ st r i ng>
</ r esour ces>
Add it to the manifest
All activities must be declared in your manifest file, Andr oi dMani f est . xml , using an <act i vi t y>element.
When you use the Eclipse tools to create the activity, it creates a default entry. If you're using a different IDE,
you need to add the manifest entry yourself. It should look like this:
<appl i cat i on . . . >
. . .
<act i vi t y
andr oi d: name=" com. exampl e. myf i r st app. Di spl ayMessageAct i vi t y"
andr oi d: l abel =" @st r i ng/ t i t l e_act i vi t y_di spl ay_message"
andr oi d: par ent Act i vi t yName=" com. exampl e. myf i r st app. Mai nAct i vi t y" >
<met a- dat a
andr oi d: name=" andr oi d. suppor t . PARENT_ACTI VI TY"
andr oi d: val ue=" com. exampl e. myf i r st app. Mai nAct i vi t y" / >
</ act i vi t y>
</ appl i cat i on>
The andr oi d: par ent Act i vi t yName attribute declares the name of this activity's parent activity within the app's
logical hierarchy. The system uses this value to implement default navigation behaviors, such as Up
navigation on Android 4.1 (API level 16) and higher. You can provide the same navigation behaviors for older
versions of Android by using the Support Library and adding the <met a- dat a>element as shown here.
Note: Your Android SDK should already include the latest Android Support Library. It's included with the ADT
Bundle but if you're using a different IDE, you should have installed it during the Adding Platforms and
Packages step. When using the templates in Eclipse, the Support Library is automatically added to your app
project (you can see the library's J AR file listed under Android Dependencies). If you're not using Eclipse, you
need to manually add the library to your projectfollow the guide for setting up the Support Library then return
here.
If you're developing with Eclipse, you can run the app now, but not much happens. Clicking the Send button
starts the second activity but it uses a default "Hello world" layout provided by the template. You'll soon update
the activity to instead display a custom text view, so if you're using a different IDE, don't worry that the app won't
yet compile.
Receive the Intent

Every Act i vi t y is invoked by an I nt ent , regardless of how the user navigated there. You can get
the I nt ent that started your activity by calling get I nt ent ( ) and retrieve the data contained within it.
In the Di spl ayMessageAct i vi t y classs onCr eat e( ) method, get the intent and extract the message
delivered by Mai nAct i vi t y:
I nt ent i nt ent = get I nt ent ( ) ;
St r i ng message = i nt ent . get St r i ngExt r a( Mai nAct i vi t y. EXTRA_MESSAGE) ;
Display the Message

To show the message on the screen, create a Text Vi ew widget and set the text using set Text ( ) . Then add
theText Vi ew as the root view of the activitys layout by passing it to set Cont ent Vi ew( ) .
The complete onCr eat e( ) method for Di spl ayMessageAct i vi t y now looks like this:
@Over r i de
publ i c voi d onCr eat e( Bundl e savedI nst anceSt at e) {
super . onCr eat e( savedI nst anceSt at e) ;

/ / Get t he message f r omt he i nt ent
I nt ent i nt ent = get I nt ent ( ) ;
St r i ng message = i nt ent . get St r i ngExt r a( Mai nAct i vi t y. EXTRA_MESSAGE) ;

/ / Cr eat e t he t ext vi ew
Text Vi ew t ext Vi ew = new Text Vi ew( t hi s) ;
t ext Vi ew. set Text Si ze( 40) ;
t ext Vi ew. set Text ( message) ;

/ / Set t he t ext vi ew as t he act i vi t y l ayout
set Cont ent Vi ew( t ext Vi ew) ;
}
You can now run the app. When it opens, type a message in the text field, click Send, and the message appears
on the second activity.

Figure 2. Both activities in the final app, running on Android 4.4.
That's it, you've built your first Android app!
To learn more, follow the link below to the next class.