編輯：關於Android編程
NotificationManager manager = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);
builder = new Notification.Builder(this);
builder.setAutoCancel(true);
builder.setSmallIcon(R.drawable.alert);
builder.setContentTitle("標題");
builder.setContentText("文本");
builder.setDefaults(Notification.DEFAULT_SOUND| Notification.DEFAULT_VIBRATE);
Intent intent = new Intent(this, SecondActivity.class); PendingIntent pIntent = PendingIntent.getActivity(this, 1, intent,PendingIntent.FLAG_ONE_SHOT); builder.setContentIntent(pIntent); manager.notify(0, builder.build());
/** * 在狀態欄顯示通知 */ private void showNotification(){ // 創建一個NotificationManager的引用 NotificationManager notificationManager = (NotificationManager) this.getSystemService(android.content.Context.NOTIFICATION_SERVICE); // 定義Notification的各種屬性 Notification notification =new Notification(R.drawable.icon, "督導系統", System.currentTimeMillis()); //FLAG_AUTO_CANCEL 該通知能被狀態欄的清除按鈕給清除掉 //FLAG_NO_CLEAR 該通知不能被狀態欄的清除按鈕給清除掉 //FLAG_ONGOING_EVENT 通知放置在正在運行 //FLAG_INSISTENT 是否一直進行，比如音樂一直播放，知道用戶響應 notification.flags |= Notification.FLAG_ONGOING_EVENT; // 將此通知放到通知欄的"Ongoing"即"正在運行"組中 notification.flags |= Notification.FLAG_NO_CLEAR; // 表明在點擊了通知欄中的"清除通知"後，此通知不清除，經常與FLAG_ONGOING_EVENT一起使用 notification.flags |= Notification.FLAG_SHOW_LIGHTS; //DEFAULT_ALL 使用所有默認值，比如聲音，震動，閃屏等等 //DEFAULT_LIGHTS 使用默認閃光提示 //DEFAULT_SOUNDS 使用默認提示聲音 //DEFAULT_VIBRATE 使用默認手機震動，需加上權限 notification.defaults = Notification.DEFAULT_LIGHTS; //疊加效果常量 //notification.defaults=Notification.DEFAULT_LIGHTS|Notification.DEFAULT_SOUND; notification.ledARGB = Color.BLUE; notification.ledOnMS =5000; //閃光時間，毫秒 // 設置通知的事件消息 CharSequence contentTitle ="督導系統標題"; // 通知欄標題 CharSequence contentText ="督導系統內容"; // 通知欄內容 Intent notificationIntent =new Intent(MainActivity.this, MainActivity.class); // 點擊該通知後要跳轉的Activity PendingIntent contentItent = PendingIntent.getActivity(this, 0, notificationIntent, 0); notification.setLatestEventInfo(this, contentTitle, contentText, contentItent); // 把Notification傳遞給NotificationManager notificationManager.notify(0, notification); } ? //刪除通知 private void clearNotification(){ // 啟動後刪除之前我們定義的通知 NotificationManager notificationManager = (NotificationManager) this .getSystemService(NOTIFICATION_SERVICE); notificationManager.cancel(0);}}
Android Notification通知詳解
根據activity的生命周期，在activity不顯示時，會執行onStop函數(比如按下home鍵)，所以你在onStop函數（按退出鍵除外）裡面把notification放在通知欄裡，再此顯示時，把notification從通知欄裡去掉。或者，只要程序在運行就一直顯示通知欄圖標。
下面對Notification類中的一些常量，字段，方法簡單介紹一下：
常量：
DEFAULT_ALL 使用所有默認值，比如聲音，震動，閃屏等等
DEFAULT_LIGHTS 使用默認閃光提示
DEFAULT_SOUNDS 使用默認提示聲音
DEFAULT_VIBRATE 使用默認手機震動
【說明】：加入手機震動，一定要在manifest.xml中加入權限：
NotificationManagerNotificationCompat
A notification is a message you can display to the user outside of your application's normal UI. When you tell the system to issue a notification, it first appears as an icon in the notification area. To see the details of the notification, the user opens the notification drawer. Both the notification area and the notification drawer are system-controlled areas that the user can view at any time.
Figure 1. Notifications in the notification area.
Figure 2. Notifications in the notification drawer.<喎?/kf/ware/vc/" target="_blank" class="keylink">vcD4KPHA+Tm90aWZpY2F0aW9uIERlc2lnbjwvcD4KPHA+Tm90aWZpY2F0aW9ucywgYXMgYW4gaW1wb3J0YW50IHBhcnQgb2YgdGhlIEFuZHJvaWQgVUksIGhhdmUgdGhlaXIgb3duIGRlc2lnbiBndWlkZWxpbmVzLiBUbyBsZWFybiBob3cgdG8gZGVzaWduIG5vdGlmaWNhdGlvbnMgYW5kIHRoZWlyIGludGVyYWN0aW9ucywgcmVhZCB0aGUgQW5kcm9pZCBEZXNpZ24gR3VpZGUgTm90aWZpY2F0aW9ucyB0b3BpYy48L3A+CjxwPk5vdGU6IEV4Y2VwdCB3aGVyZSBub3RlZCwgdGhpcyBndWlkZSByZWZlcnMgdG8gdGhlIDxjb2RlPk5vdGlmaWNhdGlvbkNvbXBhdC5CdWlsZGVyPC9jb2RlPiBjbGFzcwogaW4gdGhlIHZlcnNpb24gNCBTdXBwb3J0IExpYnJhcnkuIFRoZSBjbGFzcyA8Y29kZT5Ob3RpZmljYXRpb24uQnVpbGRlcjwvY29kZT4gd2FzCiBhZGRlZCBpbiBBbmRyb2lkIDMuMC48L3A+CjxoMj5Ob3RpZmljYXRpb24gRGlzcGxheSBFbGVtZW50czwvaDI+Cjxocj4KPHA+Tm90aWZpY2F0aW9ucyBpbiB0aGUgbm90aWZpY2F0aW9uIGRyYXdlciBjYW4gYXBwZWFyIGluIG9uZSBvZiB0d28gdmlzdWFsIHN0eWxlcywgZGVwZW5kaW5nIG9uIHRoZSB2ZXJzaW9uIGFuZCB0aGUgc3RhdGUgb2YgdGhlIGRyYXdlcjo8L3A+CjxkbD48ZHQ+Tm9ybWFsIHZpZXc8ZGQ+VGhlIHN0YW5kYXJkIHZpZXcgb2YgdGhlIG5vdGlmaWNhdGlvbnMgaW4gdGhlIG5vdGlmaWNhdGlvbiBkcmF3ZXIuPGR0PkJpZyB2aWV3PGRkPkEgbGFyZ2UgdmlldyB0aGF0"s visible when the notification is expanded. Big view is part of the expanded notification feature available as of Android 4.1.
These styles are described in the following sections.
A notification in normal view appears in an area that's up to 64 dp tall. Even if you create a notification with a big view style, it will appear in normal view until it's expanded. This is an example of a normal view:
Figure 3. Notification in normal view.
The callouts in the illustration refer to the following:
setWhen();
if you don"t it defaults to the time that the system received the notification.
A notification's big view appears only when the notification is expanded, which happens when the notification is at the top of the notification drawer, or when the user expands the notification with a gesture. Expanded notifications are available starting with Android 4.1.
The following screenshot shows an inbox-style notification:
Figure 4. Big view notification.
Notice that the big view shares most of its visual elements with the normal view. The only difference is callout number 7, the details area. Each big view style sets this area in a different way. The available styles are:
All of the big view styles also have the following content options that aren"t available in normal view:
Applying a big view style to a notification is described in the section Applying a big view style to a notification.
You specify the UI information and actions for a notification in a NotificationCompat.Builder object.
To create the notification itself, you call NotificationCompat.Builder.build(),
which returns a Notification object
containing your specifications. To issue the notification, you pass the Notification object
to the system by calling NotificationManager.notify().
A Notification object must contain
the following:
setSmallIcon()setContentTitle()setContentText()
All other notification settings and contents are optional. To learn more about them, see the reference documentation for NotificationCompat.Builder.
Although they're optional, you should add at least one action to your notification. An action allows users to go directly from the notification to an Activity in
your application, where they can look at one or more events or do further work.
A notification can provide multiple actions. You should always define the action that's triggered when the user clicks the notification; usually this action opens an Activity in
your application. You can also add buttons to the notification that perform additional actions such as snoozing an alarm or responding immediately to a text message; this feature is available as of Android 4.1. If you use additional action buttons, you must
also make their functionality available in an Activity in
your app; see the section Handling compatibility for more details.
Inside a Notification,
the action itself is defined by a PendingIntent containing
an Intent that
starts an Activity in
your application. To associate the PendingIntent with
a gesture, call the appropriate method of NotificationCompat.Builder.
For example, if you want to start Activity when
the user clicks the notification text in the notification drawer, you add the PendingIntent by
callingsetContentIntent().
Starting an Activity when
the user clicks the notification is the most common action scenario. You can also start an Activity when
the user dismisses a notification. In Android 4.1 and later, you can start an Activity from
an action button. To learn more, read the reference guide for NotificationCompat.Builder.
The following snippet illustrates a simple notification that specifies an activity to open when the user clicks the notification. Notice that the code creates a TaskStackBuilder object
and uses it to create the PendingIntent for
the action. This pattern is explained in more detail in the section Preserving Navigation when Starting
an Activity:
NotificationCompat.Builder mBuilder =
new NotificationCompat.Builder(this)
.setSmallIcon(R.drawable.notification_icon)
.setContentTitle("My notification")
.setContentText("Hello World!");
// Creates an explicit intent for an Activity in your app
Intent resultIntent = new Intent(this, ResultActivity.class);
// The stack builder object will contain an artificial back stack for the
// started Activity.
// This ensures that navigating backward from the Activity leads out of
// your application to the Home screen.
TaskStackBuilder stackBuilder = TaskStackBuilder.create(this);
// Adds the back stack for the Intent (but not the Intent itself)
stackBuilder.addParentStack(ResultActivity.class);
// Adds the Intent that starts the Activity to the top of the stack
stackBuilder.addNextIntent(resultIntent);
PendingIntent resultPendingIntent =
stackBuilder.getPendingIntent(
0,
PendingIntent.FLAG_UPDATE_CURRENT
);
mBuilder.setContentIntent(resultPendingIntent);
NotificationManager mNotificationManager =
(NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
// mId allows you to update the notification later on.
mNotificationManager.notify(mId, mBuilder.build());
That's it. Your user has now been notified.
To have a notification appear in a big view when it's expanded, first create a NotificationCompat.Builder object
with the normal view options you want. Next, call Builder.setStyle() with
a big view style object as its argument.
Remember that expanded notifications are not available on platforms prior to Android 4.1. To learn how to handle notifications for Android 4.1 and for earlier platforms, read the section Handling compatibility.
For example, the following code snippet demonstrates how to alter the notification created in the previous snippet to use the Inbox big view style:
NotificationCompat.Builder mBuilder = new NotificationCompat.Builder(this)
.setSmallIcon(R.drawable.notification_icon)
.setContentTitle("Event tracker")
.setContentText("Events received")
NotificationCompat.InboxStyle inboxStyle =
new NotificationCompat.InboxStyle();
String[] events = new String[6];
// Sets a title for the Inbox style big view
inboxStyle.setBigContentTitle("Event tracker details:");
...
// Moves events into the big view
for (int i=0; i < events.length; i++) {
inboxStyle.addLine(events[i]);
}
// Moves the big view style object into the notification object.
mBuilder.setStyle(inBoxStyle);
...
// Issue the notification here.
Not all notification features are available for a particular version, even though the methods to set them are in the support library classNotificationCompat.Builder.
For example, action buttons, which depend on expanded notifications, only appear on Android 4.1 and higher, because expanded notifications themselves are only available on Android 4.1 and higher.
To ensure the best compatibility, create notifications with NotificationCompat and
its subclasses, particularly NotificationCompat.Builder.
In addition, follow this process when you implement a notification:
Activity in
your app. You may want to add a new Activity to
do this.
For example, if you want to use addAction() to
provide a control that stops and starts media playback, first implement this control in an Activity in
your app.
Activity,
by having it start when users click the notification. To do this, create a PendingIntent for
the Activity.
Call setContentIntent() to
add the PendingIntent to
the notification.Activity that
starts when users click the notification.
When you need to issue a notification multiple times for the same type of event, you should avoid making a completely new notification. Instead, you should consider updating a previous notification, either by changing some of its values or by adding to it, or both.
For example, Gmail notifies the user that new emails have arrived by increasing its count of unread messages and by adding a summary of each email to the notification. This is called "stacking" the notification; it's described in more detail in the Notifications Design guide.
Note: This Gmail feature requires the "inbox" big view style, which is part of the expanded notification feature available starting in Android 4.1.
The following section describes how to update notifications and also how to remove them.
To set up a notification so it can be updated, issue it with a notification ID by calling NotificationManager.notify(ID,
notification). To update this notification once you've issued it, update or create a NotificationCompat.Builder object,
build a Notification object
from it, and issue the Notification with
the same ID you used previously. If the previous notification is still visible, the system updates it from the contents of the Notification object.
If the previous notification has been dismissed, a new notification is created instead.
The following snippet demonstrates a notification that is updated to reflect the number of events that have occurred. It stacks the notification, showing a summary:
mNotificationManager =
(NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
// Sets an ID for the notification, so it can be updated
int notifyID = 1;
mNotifyBuilder = new NotificationCompat.Builder(this)
.setContentTitle("New Message")
.setContentText("You've received new messages.")
.setSmallIcon(R.drawable.ic_notify_status)
numMessages = 0;
// Start of a loop that processes data and then notifies the user
...
mNotifyBuilder.setContentText(currentText)
.setNumber(++numMessages);
// Because the ID remains unchanged, the existing notification is
// updated.
mNotificationManager.notify(
notifyID,
mNotifyBuilder.build());
...
This produces a notification that looks like this:
Figure 5. Updated notification displayed in the notification drawer.
Notifications remain visible until one of the following happens:
setAutoCancel() when
you created the notification.cancel() for
a specific notification ID. This method also deletes ongoing notifications.cancelAll(),
which removes all of the notifications you previously issued.
When you start an Activity from
a notification, you must preserve the user's expected navigation experience. Clicking Back should take the user back through the application's normal work flow to the Home screen, and clicking Recents should
show the Activity as
a separate task. To preserve the navigation experience, you should start the Activity in
a fresh task. How you set up the PendingIntent to
give you a fresh task depends on the nature of the Activity you're
starting. There are two general situations:
Activity that's
part of the application's normal workflow. In this situation, set up the PendingIntent to
start a fresh task, and provide the PendingIntent with
a back stack that reproduces the application's normal Back behavior.
Notifications from the Gmail app demonstrate this. When you click a notification for a single email message, you see the message itself. Touching Back takes you backwards through Gmail to the Home screen, just as if you had entered Gmail from the Home screen rather than entering it from a notification.
This happens regardless of the application you were in when you touched the notification. For example, if you're in Gmail composing a message, and you click a notification for a single email, you go immediately to that email. Touching Back takes you to the inbox and then the Home screen, rather than taking you to the message you were composing.
Activity if
it's started from a notification. In a sense, the Activity extends
the notification by providing information that would be hard to display in the notification itself. For this situation, set up the PendingIntent to
start in a fresh task. There's no need to create a back stack, though, because the started Activity isn't
part of the application's activity flow. Clicking Back will still take the user to the Home screen.
To set up a PendingIntent that
starts a direct entry Activity,
follow these steps:
Activity hierarchy
in the manifest.
Activity you're
starting by adding a For this element, set android:name="android.support.PARENT_ACTIVITY".
Set android:value="where android:name for
the parent element.
See the following XML for an example.
android:parentActivityName attribute
to the Activity you're
starting.
The final XML should look like this:
