The {@link Notification.Builder Notification.Builder} has been added to make it * easier to construct Notifications.
* *For a guide to creating notifications, read the * Status Bar Notifications * developer guide.
** To play the default notification sound, see {@link #defaults}. *
*/ public Uri sound; /** * Use this constant as the value for audioStreamType to request that * the default stream type for notifications be used. Currently the * default stream type is STREAM_RING. */ public static final int STREAM_DEFAULT = -1; /** * The audio stream type to use when playing the sound. * Should be one of the STREAM_ constants from * {@link android.media.AudioManager}. */ public int audioStreamType = STREAM_DEFAULT; /** * The pattern with which to vibrate. * ** To vibrate the default pattern, see {@link #defaults}. *
* * @see android.os.Vibrator#vibrate(long[],int) */ public long[] vibrate; /** * The color of the led. The hardware will do its best approximation. * * @see #FLAG_SHOW_LIGHTS * @see #flags */ public int ledARGB; /** * The number of milliseconds for the LED to be on while it's flashing. * The hardware will do its best approximation. * * @see #FLAG_SHOW_LIGHTS * @see #flags */ public int ledOnMS; /** * The number of milliseconds for the LED to be off while it's flashing. * The hardware will do its best approximation. * * @see #FLAG_SHOW_LIGHTS * @see #flags */ public int ledOffMS; /** * Specifies which values should be taken from the defaults. ** To set, OR the desired from {@link #DEFAULT_SOUND}, * {@link #DEFAULT_VIBRATE}, {@link #DEFAULT_LIGHTS}. For all default * values, use {@link #DEFAULT_ALL}. *
*/ public int defaults; /** * Bit to be bitwise-ored into the {@link #flags} field that should be * set if you want the LED on for this notification. ** Since hardware varies, you are not guaranteed that any of the values * you pass are honored exactly. Use the system defaults (TODO) if possible * because they will be set to values that work on any given hardware. *
* The alpha channel must be set for forward compatibility.
*
*/
public static final int FLAG_SHOW_LIGHTS = 0x00000001;
/**
* Bit to be bitwise-ored into the {@link #flags} field that should be
* set if this notification is in reference to something that is ongoing,
* like a phone call. It should not be set if this notification is in
* reference to something that happened at a particular point in time,
* like a missed phone call.
*/
public static final int FLAG_ONGOING_EVENT = 0x00000002;
/**
* Bit to be bitwise-ored into the {@link #flags} field that if set,
* the audio will be repeated until the notification is
* cancelled or the notification window is opened.
*/
public static final int FLAG_INSISTENT = 0x00000004;
/**
* Bit to be bitwise-ored into the {@link #flags} field that should be
* set if you want the sound and/or vibration play each time the
* notification is sent, even if it has not been canceled before that.
*/
public static final int FLAG_ONLY_ALERT_ONCE = 0x00000008;
/**
* Bit to be bitwise-ored into the {@link #flags} field that should be
* set if the notification should be canceled when it is clicked by the
* user. On tablets, the
*/
public static final int FLAG_AUTO_CANCEL = 0x00000010;
/**
* Bit to be bitwise-ored into the {@link #flags} field that should be
* set if the notification should not be canceled when the user clicks
* the Clear all button.
*/
public static final int FLAG_NO_CLEAR = 0x00000020;
/**
* Bit to be bitwise-ored into the {@link #flags} field that should be
* set if this notification represents a currently running service. This
* will normally be set for you by {@link Service#startForeground}.
*/
public static final int FLAG_FOREGROUND_SERVICE = 0x00000040;
/**
* Obsolete flag indicating high-priority notifications; use the priority field instead.
*
* @deprecated Use {@link #priority} with a positive value.
*/
public static final int FLAG_HIGH_PRIORITY = 0x00000080;
public int flags;
/**
* Default notification {@link #priority}. If your application does not prioritize its own
* notifications, use this value for all notifications.
*/
public static final int PRIORITY_DEFAULT = 0;
/**
* Lower {@link #priority}, for items that are less important. The UI may choose to show these
* items smaller, or at a different position in the list, compared with your app's
* {@link #PRIORITY_DEFAULT} items.
*/
public static final int PRIORITY_LOW = -1;
/**
* Lowest {@link #priority}; these items might not be shown to the user except under special
* circumstances, such as detailed notification logs.
*/
public static final int PRIORITY_MIN = -2;
/**
* Higher {@link #priority}, for more important notifications or alerts. The UI may choose to
* show these items larger, or at a different position in notification lists, compared with
* your app's {@link #PRIORITY_DEFAULT} items.
*/
public static final int PRIORITY_HIGH = 1;
/**
* Highest {@link #priority}, for your application's most important items that require the
* user's prompt attention or input.
*/
public static final int PRIORITY_MAX = 2;
/**
* Relative priority for this notification.
*
* Priority is an indication of how much of the user's valuable attention should be consumed by
* this notification. Low-priority notifications may be hidden from the user in certain
* situations, while the user might be interrupted for a higher-priority notification. The
* system will make a determination about how to interpret notification priority as described in
* MUMBLE MUMBLE.
*/
public int priority;
/**
* Notification type: incoming call (voice or video) or similar synchronous communication request.
*/
public static final String KIND_CALL = "android.call";
/**
* Notification type: incoming direct message (SMS, instant message, etc.).
*/
public static final String KIND_MESSAGE = "android.message";
/**
* Notification type: asynchronous bulk message (email).
*/
public static final String KIND_EMAIL = "android.email";
/**
* Notification type: calendar event.
*/
public static final String KIND_EVENT = "android.event";
/**
* Notification type: promotion or advertisement.
*/
public static final String KIND_PROMO = "android.promo";
/**
* If this notification matches of one or more special types (see the Uses the {@link #icon} and {@link #when} fields to set the icon and time fields
* in the view.
* The value should be one or more of the following fields combined with
* bitwise-or:
* {@link #DEFAULT_SOUND}, {@link #DEFAULT_VIBRATE}, {@link #DEFAULT_LIGHTS}.
*
* For all default values, use {@link #DEFAULT_ALL}.
*/
public Builder setDefaults(int defaults) {
mDefaults = defaults;
return this;
}
/**
* Set the priority of this notification.
*
* @see Notification#priority
*/
public Builder setPriority(int pri) {
mPriority = pri;
return this;
}
/**
* Add a kind (category) to this notification. Optional.
*
* @see Notification#kind
*/
public Builder addKind(String k) {
mKindList.add(k);
return this;
}
/**
* Add metadata to this notification.
*
* A reference to the Bundle is held for the lifetime of this Builder, and the Bundle's
* current contents are copied into the Notification each time {@link #getNotification()} is
* called.
*
* @see Notification#extras
* @hide
*/
public Builder setExtras(Bundle bag) {
mExtras = bag;
return this;
}
/**
* Add an action to this notification. Actions are typically displayed by
* the system as a button adjacent to the notification content.
*
* @param icon Resource ID of a drawable that represents the action.
* @param title Text describing the action.
* @param intent PendingIntent to be fired when the action is invoked.
*/
public Builder addAction(int icon, CharSequence title, PendingIntent intent) {
mActions.add(new Action(icon, title, intent));
return this;
}
/**
* Specify whether this notification should pop up as an
* "intruder alert" (a small window that shares the screen with the
* current activity). This sort of notification is (as the name implies)
* very intrusive, so use it sparingly for notifications that require
* the user's attention.
*
* Notes:
* KIND_*
* constants), add them here, best match first.
*/
public String[] kind;
/**
* Extra key for people values (type TBD).
*
* @hide
*/
public static final String EXTRA_PEOPLE = "android.people";
private Bundle extras;
/**
* Structure to encapsulate an "action", including title and icon, that can be attached to a Notification.
* @hide
*/
private static class Action implements Parcelable {
public int icon;
public CharSequence title;
public PendingIntent actionIntent;
@SuppressWarnings("unused")
public Action() { }
private Action(Parcel in) {
icon = in.readInt();
title = TextUtils.CHAR_SEQUENCE_CREATOR.createFromParcel(in);
if (in.readInt() == 1) {
actionIntent = PendingIntent.CREATOR.createFromParcel(in);
}
}
public Action(int icon_, CharSequence title_, PendingIntent intent_) {
this.icon = icon_;
this.title = title_;
this.actionIntent = intent_;
}
@Override
public Action clone() {
return new Action(
this.icon,
this.title.toString(),
this.actionIntent // safe to alias
);
}
@Override
public int describeContents() {
return 0;
}
@Override
public void writeToParcel(Parcel out, int flags) {
out.writeInt(icon);
TextUtils.writeToParcel(title, out, flags);
if (actionIntent != null) {
out.writeInt(1);
actionIntent.writeToParcel(out, flags);
} else {
out.writeInt(0);
}
}
public static final Parcelable.Creator
* Notification noti = new Notification.Builder()
* .setContentTitle("New mail from " + sender.toString())
* .setContentText(subject)
* .setSmallIcon(R.drawable.new_mail)
* .setLargeIcon(aBitmap)
* .getNotification();
*
*/
public static class Builder {
private Context mContext;
private long mWhen;
private int mSmallIcon;
private int mSmallIconLevel;
private int mNumber;
private CharSequence mContentTitle;
private CharSequence mContentText;
private CharSequence mContentInfo;
private CharSequence mSubText;
private PendingIntent mContentIntent;
private RemoteViews mContentView;
private PendingIntent mDeleteIntent;
private PendingIntent mFullScreenIntent;
private CharSequence mTickerText;
private RemoteViews mTickerView;
private Bitmap mLargeIcon;
private Uri mSound;
private int mAudioStreamType;
private long[] mVibrate;
private int mLedArgb;
private int mLedOnMs;
private int mLedOffMs;
private int mDefaults;
private int mFlags;
private int mProgressMax;
private int mProgress;
private boolean mProgressIndeterminate;
private ArrayList
*
*
* @param context
* A {@link Context} that will be used by the Builder to construct the
* RemoteViews. The Context will not be held past the lifetime of this Builder
* object.
*/
public Builder(Context context) {
mContext = context;
// Set defaults to match the defaults of a Notification
mWhen = System.currentTimeMillis();
mAudioStreamType = STREAM_DEFAULT;
mPriority = PRIORITY_DEFAULT;
}
/**
* Add a timestamp pertaining to the notification (usually the time the event occurred).
*
* @see Notification#when
*/
public Builder setWhen(long when) {
mWhen = when;
return this;
}
/**
* Show the {@link Notification#when} field as a countdown (or count-up) timer instead of a timestamp.
*
* @see Notification#when
*/
public Builder setUsesChronometer(boolean b) {
mUseChronometer = b;
return this;
}
/**
* Set the small icon resource, which will be used to represent the notification in the
* status bar.
*
* The platform template for the expanded view will draw this icon in the left, unless a
* {@link #setLargeIcon(Bitmap) large icon} has also been specified, in which case the small
* icon will be moved to the right-hand side.
*
* @param icon
* A resource ID in the application's package of the drawable to use.
* @see Notification#icon
*/
public Builder setSmallIcon(int icon) {
mSmallIcon = icon;
return this;
}
/**
* A variant of {@link #setSmallIcon(int) setSmallIcon(int)} that takes an additional
* level parameter for when the icon is a {@link android.graphics.drawable.LevelListDrawable
* LevelListDrawable}.
*
* @param icon A resource ID in the application's package of the drawable to use.
* @param level The level to use for the icon.
*
* @see Notification#icon
* @see Notification#iconLevel
*/
public Builder setSmallIcon(int icon, int level) {
mSmallIcon = icon;
mSmallIconLevel = level;
return this;
}
/**
* Set the first line of text in the platform notification template.
*/
public Builder setContentTitle(CharSequence title) {
mContentTitle = title;
return this;
}
/**
* Set the second line of text in the platform notification template.
*/
public Builder setContentText(CharSequence text) {
mContentText = text;
return this;
}
/**
* Set the third line of text in the platform notification template.
* Don't use if you're also using {@link #setProgress(int, int, boolean)}; they occupy the same location in the standard template.
*/
public Builder setSubText(CharSequence text) {
mSubText = text;
return this;
}
/**
* Set the large number at the right-hand side of the notification. This is
* equivalent to setContentInfo, although it might show the number in a different
* font size for readability.
*/
public Builder setNumber(int number) {
mNumber = number;
return this;
}
/**
* A small piece of additional information pertaining to this notification.
*
* The platform template will draw this on the last line of the notification, at the far
* right (to the right of a smallIcon if it has been placed there).
*/
public Builder setContentInfo(CharSequence info) {
mContentInfo = info;
return this;
}
/**
* Set the progress this notification represents.
*
* The platform template will represent this using a {@link ProgressBar}.
*/
public Builder setProgress(int max, int progress, boolean indeterminate) {
mProgressMax = max;
mProgress = progress;
mProgressIndeterminate = indeterminate;
return this;
}
/**
* Supply a custom RemoteViews to use instead of the platform template.
*
* @see Notification#contentView
*/
public Builder setContent(RemoteViews views) {
mContentView = views;
return this;
}
/**
* Supply a {@link PendingIntent} to be sent when the notification is clicked.
*
* As of {@link android.os.Build.VERSION_CODES#HONEYCOMB}, if this field is unset and you
* have specified a custom RemoteViews with {@link #setContent(RemoteViews)}, you can use
* {@link RemoteViews#setOnClickPendingIntent RemoteViews.setOnClickPendingIntent(int,PendingIntent)}
* to assign PendingIntents to individual views in that custom layout (i.e., to create
* clickable buttons inside the notification view).
*
* @see Notification#contentIntent Notification.contentIntent
*/
public Builder setContentIntent(PendingIntent intent) {
mContentIntent = intent;
return this;
}
/**
* Supply a {@link PendingIntent} to send when the notification is cleared explicitly by the user.
*
* @see Notification#deleteIntent
*/
public Builder setDeleteIntent(PendingIntent intent) {
mDeleteIntent = intent;
return this;
}
/**
* An intent to launch instead of posting the notification to the status bar.
* Only for use with extremely high-priority notifications demanding the user's
* immediate attention, such as an incoming phone call or
* alarm clock that the user has explicitly set to a particular time.
* If this facility is used for something else, please give the user an option
* to turn it off and use a normal notification, as this can be extremely
* disruptive.
*
* @param intent The pending intent to launch.
* @param highPriority Passing true will cause this notification to be sent
* even if other notifications are suppressed.
*
* @see Notification#fullScreenIntent
*/
public Builder setFullScreenIntent(PendingIntent intent, boolean highPriority) {
mFullScreenIntent = intent;
setFlag(FLAG_HIGH_PRIORITY, highPriority);
return this;
}
/**
* Set the "ticker" text which is displayed in the status bar when the notification first
* arrives.
*
* @see Notification#tickerText
*/
public Builder setTicker(CharSequence tickerText) {
mTickerText = tickerText;
return this;
}
/**
* Set the text that is displayed in the status bar when the notification first
* arrives, and also a RemoteViews object that may be displayed instead on some
* devices.
*
* @see Notification#tickerText
* @see Notification#tickerView
*/
public Builder setTicker(CharSequence tickerText, RemoteViews views) {
mTickerText = tickerText;
mTickerView = views;
return this;
}
/**
* Add a large icon to the notification (and the ticker on some devices).
*
* In the platform template, this image will be shown on the left of the notification view
* in place of the {@link #setSmallIcon(int) small icon} (which will move to the right side).
*
* @see Notification#largeIcon
*/
public Builder setLargeIcon(Bitmap icon) {
mLargeIcon = icon;
return this;
}
/**
* Set the sound to play.
*
* It will be played on the {@link #STREAM_DEFAULT default stream} for notifications.
*
* @see Notification#sound
*/
public Builder setSound(Uri sound) {
mSound = sound;
mAudioStreamType = STREAM_DEFAULT;
return this;
}
/**
* Set the sound to play, along with a specific stream on which to play it.
*
* See {@link android.media.AudioManager} for the priority
* {@link #PRIORITY_DEFAULT} when
* now ({@link System#currentTimeMillis()}) audio stream
* {@link #STREAM_DEFAULT} STREAM_ constants.
*
* @see Notification#sound
*/
public Builder setSound(Uri sound, int streamType) {
mSound = sound;
mAudioStreamType = streamType;
return this;
}
/**
* Set the vibration pattern to use.
*
* See {@link android.os.Vibrator#vibrate(long[], int)} for a discussion of the
* pattern parameter.
*
* @see Notification#vibrate
*/
public Builder setVibrate(long[] pattern) {
mVibrate = pattern;
return this;
}
/**
* Set the desired color for the indicator LED on the device, as well as the
* blink duty cycle (specified in milliseconds).
*
* Not all devices will honor all (or even any) of these values.
*
* @see Notification#ledARGB
* @see Notification#ledOnMS
* @see Notification#ledOffMS
*/
public Builder setLights(int argb, int onMs, int offMs) {
mLedArgb = argb;
mLedOnMs = onMs;
mLedOffMs = offMs;
return this;
}
/**
* Set whether this is an "ongoing" notification.
*
* Ongoing notifications cannot be dismissed by the user, so your application or service
* must take care of canceling them.
*
* They are typically used to indicate a background task that the user is actively engaged
* with (e.g., playing music) or is pending in some way and therefore occupying the device
* (e.g., a file download, sync operation, active network connection).
*
* @see Notification#FLAG_ONGOING_EVENT
* @see Service#setForeground(boolean)
*/
public Builder setOngoing(boolean ongoing) {
setFlag(FLAG_ONGOING_EVENT, ongoing);
return this;
}
/**
* Set this flag if you would only like the sound, vibrate
* and ticker to be played if the notification is not already showing.
*
* @see Notification#FLAG_ONLY_ALERT_ONCE
*/
public Builder setOnlyAlertOnce(boolean onlyAlertOnce) {
setFlag(FLAG_ONLY_ALERT_ONCE, onlyAlertOnce);
return this;
}
/**
* Make this notification automatically dismissed when the user touches it. The
* PendingIntent set with {@link #setDeleteIntent} will be sent when this happens.
*
* @see Notification#FLAG_AUTO_CANCEL
*/
public Builder setAutoCancel(boolean autoCancel) {
setFlag(FLAG_AUTO_CANCEL, autoCancel);
return this;
}
/**
* Set which notification properties will be inherited from system defaults.
*
*
*
* @param intrude Whether to pop up an intruder alert (default false).
*/
public Builder setUsesIntruderAlert(boolean intrude) {
mCanHasIntruder = intrude;
return this;
}
/**
* Control text on intruder alert action buttons. By default, action
* buttons in intruders do not show textual labels.
*
* @param showActionText Whether to show text labels beneath action
* icons (default false).
*/
public Builder setIntruderActionsShowText(boolean showActionText) {
mIntruderActionsShowText = showActionText;
return this;
}
private void setFlag(int mask, boolean value) {
if (value) {
mFlags |= mask;
} else {
mFlags &= ~mask;
}
}
private RemoteViews applyStandardTemplate(int resId) {
RemoteViews contentView = new RemoteViews(mContext.getPackageName(), resId);
boolean hasLine3 = false;
boolean hasLine2 = false;
int smallIconImageViewId = R.id.icon;
if (mLargeIcon != null) {
contentView.setImageViewBitmap(R.id.icon, mLargeIcon);
smallIconImageViewId = R.id.right_icon;
}
if (mSmallIcon != 0) {
contentView.setImageViewResource(smallIconImageViewId, mSmallIcon);
contentView.setViewVisibility(smallIconImageViewId, View.VISIBLE);
} else {
contentView.setViewVisibility(smallIconImageViewId, View.GONE);
}
if (mContentTitle != null) {
contentView.setTextViewText(R.id.title, mContentTitle);
}
if (mContentText != null) {
contentView.setTextViewText(
(mSubText != null) ? R.id.text2 : R.id.text,
mContentText);
hasLine3 = true;
}
if (mContentInfo != null) {
contentView.setTextViewText(R.id.info, mContentInfo);
contentView.setViewVisibility(R.id.info, View.VISIBLE);
hasLine3 = true;
} else if (mNumber > 0) {
final int tooBig = mContext.getResources().getInteger(
R.integer.status_bar_notification_info_maxnum);
if (mNumber > tooBig) {
contentView.setTextViewText(R.id.info, mContext.getResources().getString(
R.string.status_bar_notification_info_overflow));
} else {
NumberFormat f = NumberFormat.getIntegerInstance();
contentView.setTextViewText(R.id.info, f.format(mNumber));
}
contentView.setViewVisibility(R.id.info, View.VISIBLE);
hasLine3 = true;
} else {
contentView.setViewVisibility(R.id.info, View.GONE);
}
if (mSubText != null) {
contentView.setTextViewText(R.id.text, mSubText);
contentView.setViewVisibility(R.id.text2, View.VISIBLE);
} else {
contentView.setViewVisibility(R.id.text2, View.GONE);
if (mProgressMax != 0 || mProgressIndeterminate) {
contentView.setProgressBar(
R.id.progress, mProgressMax, mProgress, mProgressIndeterminate);
contentView.setViewVisibility(R.id.progress, View.VISIBLE);
} else {
contentView.setViewVisibility(R.id.progress, View.GONE);
}
}
if (mWhen != 0) {
if (mUseChronometer) {
contentView.setViewVisibility(R.id.chronometer, View.VISIBLE);
contentView.setLong(R.id.chronometer, "setBase",
mWhen + (SystemClock.elapsedRealtime() - System.currentTimeMillis()));
contentView.setBoolean(R.id.chronometer, "setStarted", true);
} else {
contentView.setViewVisibility(R.id.time, View.VISIBLE);
contentView.setLong(R.id.time, "setTime", mWhen);
}
}
contentView.setViewVisibility(R.id.line3, hasLine3 ? View.VISIBLE : View.GONE);
return contentView;
}
private RemoteViews applyStandardTemplateWithActions(int layoutId) {
RemoteViews big = applyStandardTemplate(layoutId);
int N = mActions.size();
if (N > 0) {
Log.d("Notification", "has actions: " + mContentText);
big.setViewVisibility(R.id.actions, View.VISIBLE);
if (N>3) N=3;
for (int i=0; i
* Notification noti = new Notification.BigPictureStyle(
* new Notification.Builder()
* .setContentTitle("New photo from " + sender.toString())
* .setContentText(subject)
* .setSmallIcon(R.drawable.new_post)
* .setLargeIcon(aBitmap))
* .bigPicture(aBigBitmap)
* .build();
*
*
* @see Notification#bigContentView
*/
public static class BigPictureStyle {
private Builder mBuilder;
private Bitmap mPicture;
public BigPictureStyle(Builder builder) {
mBuilder = builder;
}
public BigPictureStyle bigPicture(Bitmap b) {
mPicture = b;
return this;
}
private RemoteViews makeBigContentView() {
RemoteViews contentView = mBuilder.applyStandardTemplateWithActions(R.layout.notification_template_big_picture);
contentView.setImageViewBitmap(R.id.big_picture, mPicture);
return contentView;
}
public Notification build() {
Notification wip = mBuilder.getNotification();
wip.bigContentView = makeBigContentView();
return wip;
}
}
/**
* Helper class for generating large-format notifications that include a lot of text.
*
* This class is a "rebuilder": It consumes a Builder object and modifies its behavior, like so:
*
* Notification noti = new Notification.BigPictureStyle(
* new Notification.Builder()
* .setContentTitle("New mail from " + sender.toString())
* .setContentText(subject)
* .setSmallIcon(R.drawable.new_mail)
* .setLargeIcon(aBitmap))
* .bigText(aVeryLongString)
* .build();
*
*
* @see Notification#bigContentView
*/
public static class BigTextStyle {
private Builder mBuilder;
private CharSequence mBigText;
public BigTextStyle(Builder builder) {
mBuilder = builder;
}
public BigTextStyle bigText(CharSequence cs) {
mBigText = cs;
return this;
}
private RemoteViews makeBigContentView() {
RemoteViews contentView = mBuilder.applyStandardTemplateWithActions(R.layout.notification_template_big_text);
contentView.setTextViewText(R.id.big_text, mBigText);
contentView.setViewVisibility(R.id.big_text, View.VISIBLE);
contentView.setTextViewText(R.id.text, ""); // XXX: what do do with this spot?
return contentView;
}
public Notification build() {
Notification wip = mBuilder.getNotification();
wip.bigContentView = makeBigContentView();
return wip;
}
}
/**
* Helper class for generating large-format notifications that include a list of (up to 5) strings.
*
* This class is a "rebuilder": It consumes a Builder object and modifies its behavior, like so:
*
* Notification noti = new Notification.DigestStyle(
* new Notification.Builder()
* .setContentTitle("New mail from " + sender.toString())
* .setContentText(subject)
* .setSmallIcon(R.drawable.new_mail)
* .setLargeIcon(aBitmap))
* .addLine(str1)
* .addLine(str2)
* .build();
*
*
* @see Notification#bigContentView
*/
public static class InboxStyle {
private Builder mBuilder;
private ArrayList