This lesson teaches you to
- Respond to the Send Button
- Build an Intent
- Start the Second Activity
- Create the Second Activity
- Receive the Intent
- Display the Message
You should also read
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, you’ll add some
code to MyFirstActivity
that
starts a new activity when the user selects the Send button.
Respond to the Send Button
To respond to the button's on-click event, open the main.xml
layout file and add the
android:onClick
attribute to the <Button>
element:
<Button android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="@string/button_send" android:onClick="sendMessage" />
The 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 android:onClick
,
the signature must be exactly as shown. Specifically, the method must:
- Be public
- Have a void return value
- Have a
View
as the only parameter (this will be theView
that was clicked)
Next, you’ll fill in this method to read the contents of the text field and deliver that text to another activity.
Build an Intent
An Intent
is an object that provides runtime binding between separate
components (such as two activities). The Intent
represents an
app’s "intent to do something." You can use an Intent
for a wide
variety of tasks, but most often they’re used to start another activity.
Inside the sendMessage()
method, create an Intent
to start
an activity called DisplayMessageActvity
:
Intent intent = new Intent(this, DisplayMessageActivity.class);
The constructor used here takes two parameters:
- A
Context
as its first parameter (this
is used because theActivity
class is a subclass ofContext
) - The
Class
of the app component to which the system should deliver theIntent
(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
Intent
specifies the exact app component to which the intent should be given. However, intents
can also be implicit, in which case the 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
Intent
parameters. For more informations, see the class about 与其他的App交互.
Note: The reference to 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 findViewById()
to get the
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 Intent
can carry a collection of various data types as key-value
pairs called extras. The 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 EXTRA_MESSAGE
definition to the top of the 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.
Start the Second Activity
To start an activity, you simply need to call startActivity()
and pass it your Intent
.
The system receives this call and starts an instance of the Activity
specified by the Intent
.
With this method included, the complete 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 DisplayMessageActivity
class in order for this to
work.
Create the Second Activity
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 android.app.Activity
for the superclass.
Inside the class, add the onCreate()
callback method:
public class DisplayMessageActivity extends Activity { @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); } }
All subclasses of Activity
must implement the 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.
Add it to the manifest
You must declare all activities in your manifest file, AndroidManifest.xml
, using an
<activity>
element.
Because 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 <application>
element:
<application ... > <activity android:name="com.example.myapp.DisplayMessageActivity" /> ... </application>
The app is now runnable because the Intent
in the
first activity now resolves to the DisplayMessageActivity
class. If you run the app now,
pressing the Send button starts the
second activity, but it doesn't show anything yet.
Receive the Intent
Every Activity
is invoked by an Intent
, regardless of
how the user navigated there. You can get the Intent
that started your
activity by calling getIntent()
and the retrieve data contained
within it.
In the DisplayMessageActivity
class’s onCreate()
method, get the intent and extract the message delivered by MyFirstActivity
:
Intent intent = getIntent(); String message = intent.getStringExtra(MyFirstActivity.EXTRA_MESSAGE);
Display the Message
To show the message on the screen, create a TextView
widget and set the
text using setText()
. Then add the TextView
as the root view of the activity’s layout by passing it to setContentView()
.
The complete onCreate()
method for 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 field, press Send, and view the message on the second activity.
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.