Lập trình Androi part 21 pptx

149
149
Chapter
Showing Pop-Up
Messages
Sometimes, your activity (or other piece of Android code) will need to speak up.
Not every interaction with Android users will be tidy and containable in activities
composed of views. Errors will crop up. Background tasks may take much longer than
expected. Something asynchronous may occur, such as an incoming message. In these
and other cases, you may need to communicate with the user outside the bounds of the
traditional UI.
Of course, this is nothing new. Error messages in the form of dialog boxes have been
around for a very long time. More subtle indicators also exist—from task tray icons to
bouncing dock icons to vibrating cell phones.
Android has quite a few systems for letting you alert your users outside the bounds of an
Activity-based UI. One, notifications, is tied heavily into intents and services and, as
such, is covered in Chapter 31. In this chapter, you will learn about two means of raising
pop-up messages: toasts and alerts.
Raising Toasts
A Toast is a transient message, meaning that it displays and disappears on its own
without user interaction. Moreover, it does not take focus away from the currently active
Activity, so if the user is busy writing the next Great Programming Guide, his
keystrokes will not be “eaten” by the message.
Since a Toast is transient, you have no way of knowing if the user even notices it. You
get no acknowledgment, nor does the message stick around for a long time to pester
the user. Hence, the Toast is mostly for advisory messages, such as indicating a long-
running background task is completed, the battery has dropped to a low (but not too
low) level, and so on.
14

CHAPTER 14: Showing Pop-Up Messages
150
Making a Toast is fairly easy. The Toast class offers a static makeText() that accepts a
String (or string resource ID) and returns a Toast instance. The makeText() method also
needs the Activity (or other Context) plus a duration. The duration is expressed in the
form of the LENGTH_SHORT or LENGTH_LONG constants to indicate, on a relative basis, how
long the message should remain visible.
If you would prefer your Toast be made out of some other View, rather than be a boring
old piece of text, simply create a new Toast instance via the constructor (which takes a
Context), and then call setView() to supply it with the view to use and setDuration() to
set the duration.
Once your Toast is configured, call its show() method, and the message will be
displayed.
Alert! Alert!
If you would prefer something in the more classic dialog box style, what you want is an
AlertDialog. As with any other modal dialog box, an AlertDialog pops up, grabs the
focus, and stays there until closed by the user. You might use this for a critical error, a
validation message that cannot be effectively displayed in the base activity UI, or some
other situation where you are sure that the user needs to see the message and needs to
see it now.
The simplest way to construct an AlertDialog is to use the Builder class. Following in
true builder style, Builder offers a series of methods to configure an AlertDialog, each
method returning the Builder for easy chaining. At the end, you call show() on the
builder to display the dialog.
Commonly used configuration methods on Builder include the following:
 setMessage(): Sets the “body” of the dialog to be a simple textual
message, from either a supplied String or a supplied string
resource ID.
 setTitle() and setIcon(): Configure the text and/or icon to appear in

the title bar of the dialog.
 setPositiveButton(), setNeutralButton(), and setNegativeButton():
Indicate which button(s) should appear across the bottom of the
dialog, where they should be positioned (left, center, or right,
respectively), what their captions should be, and what logic should be
invoked when the button is clicked (besides dismissing the dialog).
If you need to configure the AlertDialog beyond what the builder allows, instead of
calling show(), call create() to get the partially built AlertDialog instance, configure it
the rest of the way, and then call one of the flavors of show() on the AlertDialog itself.
Once show() is called, the dialog will appear and await user input.
CHAPTER 14: Showing Pop-Up Messages
151
Checking Them Out
To see how these work in practice, take a peek at Messages/Message, containing the
following layout:
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="
android:orientation="vertical"
android:layout_width="fill_parent"
android:layout_height="fill_parent" >
<Button
android:id="@+id/alert"
android:text="Raise an alert"
android:layout_width="fill_parent"
android:layout_height="wrap_content"/>
<Button
android:id="@+id/toast"
android:text="Make a toast"
android:layout_width="fill_parent"
android:layout_height="wrap_content"/>

</LinearLayout>
Here’s the Java code:
public class MessageDemo extends Activity implements View.OnClickListener {
Button alert;
Button toast;

@Override
public void onCreate(Bundle icicle) {
super.onCreate(icicle);

setContentView(R.layout.main);

alert=(Button)findViewById(R.id.alert);
alert.setOnClickListener(this);
toast=(Button)findViewById(R.id.toast);
toast.setOnClickListener(this);
}

public void onClick(View view) {
if (view==alert) {
new AlertDialog.Builder(this)
.setTitle("MessageDemo")
.setMessage("eek!")
.setNeutralButton("Close", new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dlg, int sumthin) {
// do nothing – it will close on its own
}
})
.show();
}

else {
Toast
.makeText(this, "<clink, clink>", Toast.LENGTH_SHORT)
CHAPTER 14: Showing Pop-Up Messages
152
.show();
}
}
}
The layout is unremarkable—just a pair of buttons to trigger the alert and the toast.
When the Raise an alert button is clicked, we use a builder (new Builder(this)) to set
the title (setTitle("MessageDemo")), message (setMessage("eek!")), and neutral button
(setNeutralButton("Close", new OnClickListener() ) before showing the dialog.
When the Close button is clicked, the OnClickListener callback does nothing; the mere
fact that the button was pressed causes the dialog to be dismissed. However, you could
update information in your activity based on the user action, particularly if you have
multiple buttons for the user to choose from. The result is a typical dialog, as shown in
Figure 14–1.

Figure 14–1. The MessageDemo sample application, after clicking the Raise an alert button
When the Make a toast button is clicked, the Toast class makes us a text-based toast
(makeText(this, "<clink, clink>", LENGTH_SHORT)), which we then show(). The result
is a short-lived, noninterrupting message, as shown in Figure 14–2.
CHAPTER 14: Showing Pop-Up Messages
153

Figure 14–2. The same application, after clicking the Make a toast button
CHAPTER 14: Showing Pop-Up Messages
154