After completing the previous lesson, you have an app that
shows an activity (a single screen) with a text box and a button. In this lesson, you’ll add some
code to MyFirstActivity that
starts a new activity when the user selects the Send button.
To respond to the button's on-click event, open the main.xml layout file and add the
{@code android:onClick}
attribute to the {@link android.widget.Button <Button>} element:
<Button android:id="@+id/button_send"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@string/button_send"
android:onClick="sendMessage" />
The {@code
android:onClick} attribute’s value, sendMessage, is the name of a method in your
activity that you want to call when the user selects the button.
Add the corresponding method inside the MyFirstActivity class:
/** Called when the user selects the Send button */
public void sendMessage(View view) {
// Do something in response to button
}
Tip: In Eclipse, press Ctrl + Shift + O to import missing classes (Cmd + Shift + O on Mac).
Note that, in order for the system to match this method to the method name given to {@code android:onClick}, the signature must be exactly as shown. Specifically, the method must:
Next, you’ll fill in this method to read the contents of the text box and deliver that text to another activity.
An {@link android.content.Intent} is an object that provides runtime binding between separate components (such as two activities). The {@link android.content.Intent} represents an app’s "intent to do something." You can use an {@link android.content.Intent} for a wide variety of tasks, but most often they’re used to start another activity.
Inside the {@code sendMessage()} method, create an {@link android.content.Intent} to start an activity called {@code DisplayMessageActvity}:
Intent intent = new Intent(this, DisplayMessageActivity.class);
The constructor used here takes two parameters:
The intent created in this lesson is what's considered an explicit intent, because the {@link android.content.Intent} specifies the exact app component to which the intent should be given. However, intents can also be implicit, in which case the {@link android.content.Intent} 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 {@link android.content.Intent} parameters. For more informations, see the class about Interacting with Other Apps.
Note: The reference to {@code DisplayMessageActivity} will raise an error if you’re using an IDE such as Eclipse because the class doesn’t exist yet. Ignore the error for now; you’ll create the class soon.
An intent not only allows you to start another activity, but can carry a bundle of data to the activity as well. So, use {@link android.app.Activity#findViewById findViewById()} to get the {@link android.widget.EditText} element and add its message to the intent:
Intent intent = new Intent(this, DisplayMessageActivity.class); EditText editText = (EditText) findViewById(R.id.edit_message); String message = editText.getText().toString(); intent.putExtra(EXTRA_MESSAGE, message);
An {@link android.content.Intent} can carry a collection of various data types as key-value pairs called extras. The {@link android.content.Intent#putExtra putExtra()} method takes a string as the key and the value in the second parameter.
In order for the next activity to query the extra data, you should define your keys using a public constant. So add the {@code EXTRA_MESSAGE} definition to the top of the {@code MyFirstActivity} class:
public class MyFirstActivity extends Activity {
public final static String EXTRA_MESSAGE = "com.example.myapp.MESSAGE";
...
}
It's generally a good practice to define keys for extras with your app's package name as a prefix to ensure it's unique, in case your app interacts with other apps.
To start an activity, you simply need to call {@link android.app.Activity#startActivity startActivity()} and pass it your {@link android.content.Intent}.
The system receives this call and starts an instance of the {@link android.app.Activity} specified by the {@link android.content.Intent}.
With this method included, the complete {@code sendMessage()} method that's invoked by the Send button now looks like this:
/** Called when the user selects the Send button */
public void sendMessage(View view) {
Intent intent = new Intent(this, DisplayMessageActivity.class);
EditText editText = (EditText) findViewById(R.id.edit_message);
String message = editText.getText().toString();
intent.putExtra(EXTRA_MESSAGE, message);
startActivity(intent);
}
Now you need to create the {@code DisplayMessageActivity} class in order for this to work.
In your project, create a new class file under the src/<package-name>/
directory called DisplayMessageActivity.java.
Tip: In Eclipse, right-click the package name under the
src/ directory and select New > Class.
Enter "DisplayMessageActivity" for the name and {@code android.app.Activity} for the superclass.
Inside the class, add the {@link android.app.Activity#onCreate onCreate()} callback method:
public class DisplayMessageActivity extends Activity {
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
}
}
All subclasses of {@link android.app.Activity} must implement the {@link android.app.Activity#onCreate onCreate()} method. The system calls this when creating a new instance of the activity. It is where you must define the activity layout and where you should initialize essential activity components.
You must declare all activities in your manifest file, AndroidManifest.xml, using an
{@code <activity>} element.
Because {@code DisplayMessageActivity} is invoked using an explicit intent, it does not require
any intent filters (such as those you can see in the manifest for MyFirstActivity). So
the declaration for DisplayMessageActivity can be simply one line of code inside the {@code <application>}
element:
<application ... >
<activity android:name="com.example.myapp.DisplayMessageActivity" />
...
</application>
The app is now runnable because the {@link android.content.Intent} in the first activity now resolves to the {@code DisplayMessageActivity} class. If you run the app now, pressing the Send button starts the second activity, but it doesn't show anything yet.
Every {@link android.app.Activity} is invoked by an {@link android.content.Intent}, regardless of how the user navigated there. You can get the {@link android.content.Intent} that started your activity by calling {@link android.app.Activity#getIntent()} and the retrieve data contained within it.
In the {@code DisplayMessageActivity} class’s {@link android.app.Activity#onCreate onCreate()} method, get the intent and extract the message delivered by {@code MyFirstActivity}:
Intent intent = getIntent(); String message = intent.getStringExtra(MyFirstActivity.EXTRA_MESSAGE);
To show the message on the screen, create a {@link android.widget.TextView} widget and set the text using {@link android.widget.TextView#setText setText()}. Then add the {@link android.widget.TextView} as the root view of the activity’s layout by passing it to {@link android.app.Activity#setContentView setContentView()}.
The complete {@link android.app.Activity#onCreate onCreate()} method for {@code DisplayMessageActivity} now looks like this:
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
// Get the message from the intent
Intent intent = getIntent();
String message = intent.getStringExtra(MyFirstActivity.EXTRA_MESSAGE);
// Create the text view
TextView textView = new TextView(this);
textView.setTextSize(40);
textView.setText(message);
setContentView(textView);
}
You can now run the app, type a message in the text box, press Send, and view the message on the second activity.
Figure 1. Both activities in the final app, running on Android 4.0.
That's it, you've built your first Android app!
To learn more about building Android apps, continue to follow the basic training classes. The next class is Managing the Activity Lifecycle.