Android Notification通知详细解释
Android Notification通知具体解释
Notification所代表的是一种具有全局效果的通知,程序一般通过NotificationManager服务来发送Notification。
应用程序能够通过NotificationManager 向系统发送全局通知;
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());
- Intent是马上使用的,而PendingIntent能够等到事件发生后触发,PendingIntent能够cancel。
- Intent在程序结束后即终止,而PendingIntent在程序结束后依旧有效;
- PendingIntent自带Context,而Intent须要在某个Context内执行;
- Intent在原task中执行。PendingIntent在新的task中执行。
- FLAG_ONE_SHOT : 这个PendingIntent仅仅能使用一次。
- FLAG_NO_CREATE : 假设被描写叙述的PendingIntent不存在,那么简单地返回null,而不是创建它。
- FLAG_CANCEL_CURRENT : 假设被描写叙述的PendingIntent已经存在,在即将生成一个新的PendingIntent前,当前的一个要被取消。
- FLAG_UPDATE_CURRENT :假设被描写叙述的PendingIntent已经存在,那么继续保持它。但它当中的数据会由于新Intent而更新。
NotificationCompat.Builder builder = new NotificationCompat.Builder(
MainActivity.this);
builder.setContentText("344444444444");
builder.setContentTitle("33333333333");
builder.setSmallIcon(R.drawable.ic_launcher);
Intent intent = new Intent(MainActivity.this,
ScondActivity.class);
PendingIntent intent2 = PendingIntent.getActivity(
MainActivity.this, 1, intent,
PendingIntent.FLAG_CANCEL_CURRENT);
builder.setContentIntent(intent2);
NotificationManager notificationManager = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);
notificationManager.notify(1, 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 该通知能被状态栏的清除button给清除掉//FLAG_NO_CLEAR 该通知不能被状态栏的清除button给清除掉//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 使用默认手机震动。需加上<uses-permission android:name="android.permission.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); }} |
1. [代码][Java]代码
Android Notification通知具体解释依据activity的生命周期。在activity不显示时,会执行onStop函数(比方按下home键),所以你在onStop函数(按退出键除外)里面把notification放在通知栏里,再此显示时,把notification从通知栏里去掉。或者。仅仅要程序在执行就一直显示通知栏图标。以下对Notification类中的一些常量,字段,方法简介一下: 常量: DEFAULT_ALL 使用全部默认值。比方声音,震动,闪屏等等 DEFAULT_LIGHTS 使用默认闪光提示 DEFAULT_SOUNDS 使用默认提示声音 DEFAULT_VIBRATE 使用默认手机震动 【说明】:增加手机震动,一定要在manifest.xml中增加权限: <uses-permission android:name="android.permission.VIBRATE" /> 以上的效果常量能够叠加,即通过 notification.defaults =DEFAULT_SOUND|DEFAULT_VIBRATE; notification.defaults |= DEFAULT_SOUND (最好在真机上測试,震动效果模拟器上没有)//设置flag位 FLAG_AUTO_CANCEL 该通知能被状态栏的清除button给清除掉 FLAG_NO_CLEAR 该通知能被状态栏的清除button给清除掉 FLAG_ONGOING_EVENT 通知放置在正在执行 FLAG_INSISTENT 是否一直进行,比方音乐一直播放,知道用户响应经常使用字段: contentIntent 设置PendingIntent对象,点击时发送该Intent defaults 增加默认效果 flags 设置flag位,比如FLAG_NO_CLEAR等 icon 设置图标 sound 设置声音 tickerText 显示在状态栏中的文字 when 发送此通知的时间戳NotificationManager经常用法介绍: public void cancelAll() 移除全部通知(仅仅是针对当前Context下的Notification) public void cancel(int id) 移除标记为id的通知 (仅仅是针对当前Context下的全部Notification) public void notify(String tag ,int id, Notification notification) 将通知增加状态栏。标签为tag,标记为id public void notify(int id, Notification notification) 将通知增加状态栏。标记为id
Notifications
In this document
- Notification Display Elements
- Normal view
- Big view
- Creating a Notification
- Required notification contents
- Optional notification contents and settings
- Notification actions
- Creating a simple notification
- Applying a big view style to a notification
- Handling compatibility
- Managing Notifications
- Updating notifications
- Removing notifications
- Preserving Navigation when Starting an Activity
- Setting up a regular activity PendingIntent
- Setting up a special activity PendingIntent
- Displaying Progress in a Notification
- Displaying a fixed-duration progress indicator
- Displaying a continuing activity indicator
- Custom Notification Layouts
Key classes
NotificationManager
NotificationCompat
Videos
- Notifications in 4.1
See also
- Android Design: Notifications
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.
Notification Design
Notifications, as an important part of the Android UI, have their own design guidelines. To learn how to design notifications and their interactions, read the Android Design Guide Notifications topic.
Note: Except where noted, this guide refers to the NotificationCompat.Builder
class in the version 4 Support Library. The class Notification.Builder
was added in Android 3.0.
Notification Display Elements
Notifications in the notification drawer can appear in one of two visual styles, depending on the version and the state of the drawer:
- Normal view
- The standard view of the notifications in the notification drawer.
- Big view
- A large view that'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.
Normal view
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:
- Content title
- Large icon
- Content text
- Content info
- Small icon
- Time that the notification was issued. You can set an explicit value with
setWhen()
; if you don't it defaults to the time that the system received the notification.
Big view
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:
- Big picture style
- The details area contains a bitmap up to 256 dp tall in its detail section.
- Big text style
- Displays a large text block in the details section.
- Inbox style
- Displays lines of text in the details section.
All of the big view styles also have the following content options that aren't available in normal view:
- Big content title
- Allows you to override the normal view's content title with a title that appears only in the expanded view.
- Summary text
- Allows you to add a line of text below the details area.
Applying a big view style to a notification is described in the section Applying a big view style to a notification.
Creating 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()
.
Required notification contents
A Notification
object must contain the following:
- A small icon, set by
setSmallIcon()
- A title, set by
setContentTitle()
- Detail text, set by
setContentText()
Optional notification contents and settings
All other notification settings and contents are optional. To learn more about them, see the reference documentation for NotificationCompat.Builder
.
Notification actions
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
.
Creating a simple notification
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 appIntent 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 stackstackBuilder.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.
Applying a big view style to a notification
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 viewinboxStyle.setBigContentTitle("Event tracker details:");...// Moves events into the big viewfor (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.
Handling compatibility
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:
- Provide all of the notification's functionality to all users, regardless of the version they're using. To do this, verify that all of the functionality is available from an
Activity
in your app. You may want to add a newActivity
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 anActivity
in your app. - Ensure that all users can get to the functionality in the
Activity
, by having it start when users click the notification. To do this, create aPendingIntent
for theActivity
. CallsetContentIntent()
to add thePendingIntent
to the notification. - Now add the expanded notification features you want to use to the notification. Remember that any functionality you add also has to be available in the
Activity
that starts when users click the notification.
Managing Notifications
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.
Updating notifications
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 updatedint 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.
Removing notifications
Notifications remain visible until one of the following happens:
- The user dismisses the notification either individually or by using "Clear All" (if the notification can be cleared).
- The user clicks the notification, and you called
setAutoCancel()
when you created the notification. - You call
cancel()
for a specific notification ID. This method also deletes ongoing notifications. - You call
cancelAll()
, which removes all of the notifications you previously issued.
Preserving Navigation when Starting an Activity
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:
- Regular activity
-
You're starting an
Activity
that's part of the application's normal workflow. In this situation, set up thePendingIntent
to start a fresh task, and provide thePendingIntent
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.
- Special activity
-
The user only sees this
Activity
if it's started from a notification. In a sense, theActivity
extends the notification by providing information that would be hard to display in the notification itself. For this situation, set up thePendingIntent
to start in a fresh task. There's no need to create a back stack, though, because the startedActivity
isn't part of the application's activity flow. Clicking Back will still take the user to the Home screen.
Setting up a regular activity PendingIntent
To set up a PendingIntent
that starts a direct entry Activity
, follow these steps:
- Define your application's
Activity
hierarchy in the manifest.- Add support for Android 4.0.3 and earlier. To do this, specify the parent of the
Activity
you're starting by adding a<meta-data>
element as the child of the<activity>
.For this element, set
android:name="android.support.PARENT_ACTIVITY"
. Setandroid:value="<parent_activity_name>"
where<parent_activity_name>
is the value ofandroid:name
for the parent<activity>
element. See the following XML for an example. - Also add support for Android 4.1 and later. To do this, add the
android:parentActivityName
attribute to the<activity>
element of theActivity
you're starting.
The final XML should look like this:
<activity android:name=".MainActivity" android:label="@string/app_name" > <intent-filter> <action android:name="android.intent.action.MAIN" /> <category android:name="android.intent.category.LAUNCHER" /> </intent-filter></activity><activity android:name=".ResultActivity" android:parentActivityName=".MainActivity"> <meta-data android:name="android.support.PARENT_ACTIVITY" android:value=".MainActivity"/></activity>
- Add support for Android 4.0.3 and earlier. To do this, specify the parent of the
- Create a back stack based on the
Intent
that starts theActivity
:- Create the
Intent
to start theActivity
. - Create a stack builder by calling
TaskStackBuilder.create()
. - Add the back stack to the stack builder by calling
addParentStack()
. For eachActivity
in the hierarchy you've defined in the manifest, the back stack contains anIntent
object that starts theActivity
. This method also adds flags that start the stack in a fresh task.Note: Although the argument to
addParentStack()
is a reference to the startedActivity
, the method call doesn't add theIntent
that starts theActivity
. Instead, that's taken care of in the next step. - Add the
Intent
that starts theActivity
from the notification, by callingaddNextIntent()
. Pass theIntent
you created in the first step as the argument toaddNextIntent()
. - If you need to, add arguments to
Intent
objects on the stack by callingTaskStackBuilder.editIntentAt()
. This is sometimes necessary to ensure that the targetActivity
displays meaningful data when the user navigates to it using Back. - Get a
PendingIntent
for this back stack by callinggetPendingIntent()
. You can then use thisPendingIntent
as the argument tosetContentIntent()
.
- Create the
The following code snippet demonstrates the process:
...Intent resultIntent = new Intent(this, ResultActivity.class);TaskStackBuilder stackBuilder = TaskStackBuilder.create(this);// Adds the back stackstackBuilder.addParentStack(ResultActivity.class);// Adds the Intent to the top of the stackstackBuilder.addNextIntent(resultIntent);// Gets a PendingIntent containing the entire back stackPendingIntent resultPendingIntent = stackBuilder.getPendingIntent(0, PendingIntent.FLAG_UPDATE_CURRENT);...NotificationCompat.Builder builder = new NotificationCompat.Builder(this);builder.setContentIntent(resultPendingIntent);NotificationManager mNotificationManager = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);mNotificationManager.notify(id, builder.build());
Setting up a special activity PendingIntent
The following section describes how to set up a special activity PendingIntent
.
A special Activity
doesn't need a back stack, so you don't have to define its Activity
hierarchy in the manifest, and you don't have to call addParentStack()
to build a back stack. Instead, use the manifest to set up the Activity
task options, and create the PendingIntent
by calling getActivity()
:
- In your manifest, add the following attributes to the
<activity>
element for theActivity
-
android:name="activityclass"
- The activity's fully-qualified class name.
-
android:taskAffinity=""
-
Combined with the
FLAG_ACTIVITY_NEW_TASK
flag that you set in code, this ensures that thisActivity
doesn't go into the application's default task. Any existing tasks that have the application's default affinity are not affected. -
android:excludeFromRecents="true"
- Excludes the new task from Recents, so that the user can't accidentally navigate back to it.
This snippet shows the element:
<activity android:name=".ResultActivity"... android:launchMode="singleTask" android:taskAffinity="" android:excludeFromRecents="true"></activity>...
-
- Build and issue the notification:
- Create an
Intent
that starts theActivity
. - Set the
Activity
to start in a new, empty task by callingsetFlags()
with the flagsFLAG_ACTIVITY_NEW_TASK
andFLAG_ACTIVITY_CLEAR_TASK
. - Set any other options you need for the
Intent
. - Create a
PendingIntent
from theIntent
by callinggetActivity()
. You can then use thisPendingIntent
as the argument tosetContentIntent()
.
The following code snippet demonstrates the process:
// Instantiate a Builder object.NotificationCompat.Builder builder = new NotificationCompat.Builder(this);// Creates an Intent for the ActivityIntent notifyIntent = new Intent(new ComponentName(this, ResultActivity.class));// Sets the Activity to start in a new, empty tasknotifyIntent.setFlags(FLAG_ACTIVITY_NEW_TASK | FLAG_ACTIVITY_CLEAR_TASK);// Creates the PendingIntentPendingIntent notifyIntent = PendingIntent.getActivity( this, 0, notifyIntent PendingIntent.FLAG_UPDATE_CURRENT); // Puts the PendingIntent into the notification builderbuilder.setContentIntent(notifyIntent);// Notifications are issued by sending them to the// NotificationManager system service.NotificationManager mNotificationManager = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);// Builds an anonymous Notification object from the builder, and// passes it to the NotificationManagermNotificationManager.notify(id, builder.build());
- Create an
Displaying Progress in a Notification
Notifications can include an animated progress indicator that shows users the status of an ongoing operation. If you can estimate how long the operation takes and how much of it is complete at any time, use the "determinate" form of the indicator (a progress bar). If you can't estimate the length of the operation, use the "indeterminate" form of the indicator (an activity indicator).
Progress indicators are displayed with the platform's implementation of the ProgressBar
class.
To use a progress indicator on platforms starting with Android 4.0, call setProgress()
. For previous versions, you must create your own custom notification layout that includes a ProgressBar
view.
The following sections describe how to display progress in a notification using setProgress()
.
Displaying a fixed-duration progress indicator
To display a determinate progress bar, add the bar to your notification by calling setProgress() setProgress(max, progress, false)
and then issue the notification. As your operation proceeds, increment progress
, and update the notification. At the end of the operation, progress
should equal max
. A common way to call setProgress()
is to set max
to 100 and then increment progress
as a "percent complete" value for the operation.
You can either leave the progress bar showing when the operation is done, or remove it. In either case, remember to update the notification text to show that the operation is complete. To remove the progress bar, call setProgress() setProgress(0, 0, false)
. For example:
...mNotifyManager = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);mBuilder = new NotificationCompat.Builder(this);mBuilder.setContentTitle("Picture Download") .setContentText("Download in progress") .setSmallIcon(R.drawable.ic_notification);// Start a lengthy operation in a background threadnew Thread( new Runnable() { @Override public void run() { int incr; // Do the "lengthy" operation 20 times for (incr = 0; incr <= 100; incr+=5) { // Sets the progress indicator to a max value, the // current completion percentage, and "determinate" // state mBuilder.setProgress(100, incr, false); // Displays the progress bar for the first time. mNotifyManager.notify(0, mBuilder.build()); // Sleeps the thread, simulating an operation // that takes time try { // Sleep for 5 seconds Thread.sleep(5*1000); } catch (InterruptedException e) { Log.d(TAG, "sleep failure"); } } // When the loop is finished, updates the notification mBuilder.setContentText("Download complete") // Removes the progress bar .setProgress(0,0,false); mNotifyManager.notify(ID, mBuilder.build()); } }// Starts the thread by calling the run() method in its Runnable).start();
The resulting notifications are shown in figure 6. On the left side is a snapshot of the notification during the operation; on the right side is a snapshot of it after the operation has finished.
Figure 6. The progress bar during and after the operation.
Displaying a continuing activity indicator
To display an indeterminate activity indicator, add it to your notification with setProgress(0, 0, true)
(the first two arguments are ignored), and issue the notification. The result is an indicator that has the same style as a progress bar, except that its animation is ongoing.
Issue the notification at the beginning of the operation. The animation will run until you modify your notification. When the operation is done, call setProgress() setProgress(0, 0, false)
and then update the notification to remove the activity indicator. Always do this; otherwise, the animation will run even when the operation is complete. Also remember to change the notification text to indicate that the operation is complete.
To see how activity indicators work, refer to the preceding snippet. Locate the following lines:
// Sets the progress indicator to a max value, the current completion// percentage, and "determinate" statemBuilder.setProgress(100, incr, false);// Issues the notificationmNotifyManager.notify(0, mBuilder.build());
Replace the lines you've found with the following lines:
// Sets an activity indicator for an operation of indeterminate lengthmBuilder.setProgress(0, 0, true);// Issues the notificationmNotifyManager.notify(0, mBuilder.build());
The resulting indicator is shown in figure 7:
Figure 7. An ongoing activity indicator.
Custom Notification Layouts
The notifications framework allows you to define a custom notification layout, which defines the notification's appearance in a RemoteViews
object. Custom layout notifications are similar to normal notifications, but they're based on a RemoteViews
defined in a XML layout file.
The height available for a custom notification layout depends on the notification view. Normal view layouts are limited to 64 dp, and expanded view layouts are limited to 256 dp.
To define a custom notification layout, start by instantiating a RemoteViews
object that inflates an XML layout file. Then, instead of calling methods such as setContentTitle()
, call setContent()
. To set content details in the custom notification, use the methods inRemoteViews
to set the values of the view's children:
- Create an XML layout for the notification in a separate file. You can use any file name you wish, but you must use the extension
.xml
- In your app, use
RemoteViews
methods to define your notification's icons and text. Put thisRemoteViews
object into yourNotificationCompat.Builder
by callingsetContent()
. Avoid setting a backgroundDrawable
on yourRemoteViews
object, because your text color may become unreadable.
The RemoteViews
class also includes methods that you can use to easily add a Chronometer
or ProgressBar
to your notification's layout. For more information about creating custom layouts for your notification, refer to the RemoteViews
reference documentation.
Caution: When you use a custom notification layout, take special care to ensure that your custom layout works with different device orientations and resolutions. While this advice applies to all View layouts, it's especially important for notifications because the space in the notification drawer is very restricted. Don't make your custom layout too complex, and be sure to test it in various configurations.
Using style resources for custom notification text
Always use style resources for the text of a custom notification. The background color of the notification can vary across different devices and versions, and using style resources helps you account for this. Starting in Android 2.3, the system defined a style for the standard notification layout text. If you use the same style in applications that target Android 2.3 or higher, you'll ensure that your text is visible against the display background.
版权声明:本文博主原创文章,博客,未经同意不得转载。
转载于:https://www.cnblogs.com/mengfanrong/p/4785067.html
Android Notification通知详细解释相关推荐
- Android Notification通知详解
Android Notification通知详解 Notification: (一).简介: 显示在手机状态栏的通知.Notification所代表的是一种具有全局效果的通知,程序一般通过Notifi ...
- Android Notification通知RemoteView布局使用ConstraintLayout报错
Android Notification通知RemoteView布局使用ConstraintLayout报错:inflate error ? Notification的自定义布局是RemoteView ...
- 四十一、Android Notification通知详解
根据activity的生命周期,在activity不显示时,会执行onStop函数(比如按下home键),所以你在onStop函数(按退出键除外)里面把notification放在通知栏里,再此显示时 ...
- Android在Context详细解释 ---- 你不知道Context
...
- Android发送通知——通知栏(Notification)
Android发送通知--通知栏(Notification) 通知是指 Android 在您应用的界面之外显示的消息,旨在向用户提供提醒.来自他人的通信信息或您应用中的其他实时信息.在发出一条通知后, ...
- android notification设置不同字体颜色,Android Notification自定义通知样式你要知道的事...
本文将根据个人经验对Notification做个总结,以供参考! 什么是通知(Notification) 通知是一个可以在应用程序正常的用户界面之外显示给用户的消息. 通知发出时,它首先出现在状态栏的 ...
- Android Notification状态栏通知
没有增加额外的震动及声音效果,这里直接实现了通知的功能,看效果吧: MainActivity.java package com.example.notification;import android. ...
- android notification应用之自定义来电通知
android notification应用之自定义来电通知 1.为了实现老板的各种要求 本人矜矜业业完成任务 随着这个软电话软件的日益完善 本来来电的时候是创建一条通知点亮屏幕 用户可以解锁屏幕后接 ...
- 利用android的通知Notification来实现msn的登录状态
Notification,状态栏.看得出来就是和我们PC机一样,在某一区域有个标志,需要请求它就去点这个标志就可以打开这个程序了. 先来介绍下需要用到的一些属于android下的类:Intent.No ...
最新文章
- 实验三 JSP应用开发进阶
- 如何快捷高效实现仓储精细化、透明化管理?
- java数据结构实验一顺序表,java数据结构实验代码之升序顺序表
- ubuntu添加dvd光盘源
- pytorch教程龙曲良46-55
- Django从理论到实战(part4)--创建我们的第一个页面
- mysql 安装测试ok_tpcc-mysql安装测试与使用的实例教程
- android传感器博客,Android实现接近传感器
- 连续4年财务造假 造假金额过亿!捧红杨幂的欢瑞世纪被重罚
- 人工神经网络算法原理和应用
- mpls工作原理通俗解释_马自达3 压燃上市的关头,解释X发动机的工作原理
- 清华大学发布OpenNE:用于网络嵌入的开源工具包
- php支持的协议与封装协议
- 有限域f9的特征是多少_密码学数学基本第十一讲有限域.ppt
- thisisunsafe的神奇之chrome浏览器打不开不安全的https网页
- php扩展exif模块,Centos+PHP模块+exif扩展 (第三方模块)
- Halcon匹配助手
- 使用‘终端’融合磁盘然后进行MAC重装系统
- CN-DBpedia备忘
- NTFS文件系统详解(三)NTFS元文件解析
热门文章
- LINUX关闭防火墙、开放特定端口等常用操作
- 无法输入中文标点符号问题解决方案【亲测有效】
- 商业模式,淘宝,拼多多,京东,短视频商业模式
- 打开计算机首先映入眼帘的一整屏称之为桌面,利用“活动桌面” 让桌面也“闪”起来...
- 【转载】Microsoft 365 E5邮件API调用自动订阅无限续订服务
- 生态篇-HBase 进化之从 NoSQL 到 NewSQL,凤凰涅槃成就 Phoenix
- 中国物联网微控制器市场现状研究分析与发展前景预测报告(2022)
- 北极熊秀舞步神似美国明星
- 华为云服务器还需要确定位置吗,有了云服务器还需要主机吗
- 弄懂这56个Python技巧,秒变Python大神