* Each of the notify methods takes an int id parameter and optionally a * {@link String} tag parameter, which may be {@code null}. These parameters * are used to form a pair (tag, id), or ({@code null}, id) if tag is * unspecified. This pair identifies this notification from your app to the * system, so that pair should be unique within your app. If you call one * of the notify methods with a (tag, id) pair that is currently active and * a new set of notification parameters, it will be updated. For example, * if you pass a new status bar icon, the old icon in the status bar will * be replaced with the new one. This is also the same tag and id you pass * to the {@link #cancel(int)} or {@link #cancel(String, int)} method to clear * this notification. * *
For a guide to creating notifications, read the * Status Bar Notifications * developer guide.
** Group information is only used for presentation, not for behavior. Groups are optional * for channels, and you can have a mix of channels that belong to groups and channels * that do not. *
** For example, if your application supports multiple accounts, and those accounts will * have similar channels, you can create a group for each account with account specific * labels instead of appending account information to each channel's label. *
* * @param group The group to create */ public void createNotificationChannelGroup(@NonNull NotificationChannelGroup group) { createNotificationChannelGroups(Arrays.asList(group)); } /** * Creates multiple notification channel groups. * * @param groups The list of groups to create */ public void createNotificationChannelGroups(@NonNull ListThe name and description should only be changed if the locale changes * or in response to the user renaming this channel. For example, if a user has a channel * named 'John Doe' that represents messages from a 'John Doe', and 'John Doe' changes his name * to 'John Smith,' the channel can be renamed to match. * *
The importance of an existing channel will only be changed if the new importance is lower * than the current value and the user has not altered any settings on this channel. * *
The group an existing channel will only be changed if the channel does not already
* belong to a group.
*
* All other fields are ignored for channels that already exist.
*
* @param channel the channel to create. Note that the created channel may differ from this
* value. If the provided channel is malformed, a RemoteException will be
* thrown.
*/
public void createNotificationChannel(@NonNull NotificationChannel channel) {
createNotificationChannels(Arrays.asList(channel));
}
/**
* Creates multiple notification channels that different notifications can be posted to. See
* {@link #createNotificationChannel(NotificationChannel)}.
*
* @param channels the list of channels to attempt to create.
*/
public void createNotificationChannels(@NonNull List If you {@link #createNotificationChannel(NotificationChannel) create} a new channel with
* this same id, the deleted channel will be un-deleted with all of the same settings it
* had before it was deleted.
*/
public void deleteNotificationChannel(String channelId) {
INotificationManager service = getService();
try {
service.deleteNotificationChannel(mContext.getPackageName(), channelId);
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
}
/**
* Returns the notification channel group settings for a given channel group id.
*
* The channel group must belong to your package, or null will be returned.
*/
public NotificationChannelGroup getNotificationChannelGroup(String channelGroupId) {
INotificationManager service = getService();
try {
return service.getNotificationChannelGroup(mContext.getPackageName(), channelGroupId);
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
}
/**
* Returns all notification channel groups belonging to the calling app.
*/
public List
* Throws a SecurityException if policy access is granted to this package.
* See {@link #isNotificationPolicyAccessGranted}.
*/
public Map
* Throws a SecurityException if policy access is granted to this package.
* See {@link #isNotificationPolicyAccessGranted}.
*
*
* Returns null if there are no zen rules that match the given id, or if the calling package
* doesn't own the matching rule. See {@link AutomaticZenRule#getOwner}.
*/
public AutomaticZenRule getAutomaticZenRule(String id) {
INotificationManager service = getService();
try {
return service.getAutomaticZenRule(id);
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
}
/**
* Creates the given zen rule.
*
*
* Throws a SecurityException if policy access is granted to this package.
* See {@link #isNotificationPolicyAccessGranted}.
*
* @param automaticZenRule the rule to create.
* @return The id of the newly created rule; null if the rule could not be created.
*/
public String addAutomaticZenRule(AutomaticZenRule automaticZenRule) {
INotificationManager service = getService();
try {
return service.addAutomaticZenRule(automaticZenRule);
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
}
/**
* Updates the given zen rule.
*
*
* Throws a SecurityException if policy access is granted to this package.
* See {@link #isNotificationPolicyAccessGranted}.
*
*
* Callers can only update rules that they own. See {@link AutomaticZenRule#getOwner}.
* @param id The id of the rule to update
* @param automaticZenRule the rule to update.
* @return Whether the rule was successfully updated.
*/
public boolean updateAutomaticZenRule(String id, AutomaticZenRule automaticZenRule) {
INotificationManager service = getService();
try {
return service.updateAutomaticZenRule(id, automaticZenRule);
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
}
/**
* Deletes the automatic zen rule with the given id.
*
*
* Throws a SecurityException if policy access is granted to this package.
* See {@link #isNotificationPolicyAccessGranted}.
*
*
* Callers can only delete rules that they own. See {@link AutomaticZenRule#getOwner}.
* @param id the id of the rule to delete.
* @return Whether the rule was successfully deleted.
*/
public boolean removeAutomaticZenRule(String id) {
INotificationManager service = getService();
try {
return service.removeAutomaticZenRule(id);
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
}
/**
* Deletes all automatic zen rules owned by the given package.
*
* @hide
*/
public boolean removeAutomaticZenRules(String packageName) {
INotificationManager service = getService();
try {
return service.removeAutomaticZenRules(packageName);
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
}
/**
* Returns the user specified importance for notifications from the calling
* package.
*/
public @Importance int getImportance() {
INotificationManager service = getService();
try {
return service.getPackageImportance(mContext.getPackageName());
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
}
/**
* Returns whether notifications from the calling package are blocked.
*/
public boolean areNotificationsEnabled() {
INotificationManager service = getService();
try {
return service.areNotificationsEnabled(mContext.getPackageName());
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
}
/**
* Checks the ability to modify notification do not disturb policy for the calling package.
*
*
* Returns true if the calling package can modify notification policy.
*
*
* Apps can request policy access by sending the user to the activity that matches the system
* intent action {@link android.provider.Settings#ACTION_NOTIFICATION_POLICY_ACCESS_SETTINGS}.
*
*
* Use {@link #ACTION_NOTIFICATION_POLICY_ACCESS_GRANTED_CHANGED} to listen for
* user grant or denial of this access.
*/
public boolean isNotificationPolicyAccessGranted() {
INotificationManager service = getService();
try {
return service.isNotificationPolicyAccessGranted(mContext.getOpPackageName());
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
}
/**
* Checks whether the user has approved a given
* {@link android.service.notification.NotificationListenerService}.
*
*
* The listener service must belong to the calling app.
*
*
* Apps can request notification listener access by sending the user to the activity that
* matches the system intent action
* {@link android.provider.Settings#ACTION_NOTIFICATION_LISTENER_SETTINGS}.
*/
public boolean isNotificationListenerAccessGranted(ComponentName listener) {
INotificationManager service = getService();
try {
return service.isNotificationListenerAccessGranted(listener);
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
}
/**
* @hide
*/
public boolean isNotificationAssistantAccessGranted(ComponentName assistant) {
INotificationManager service = getService();
try {
return service.isNotificationAssistantAccessGranted(assistant);
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
}
/** @hide */
public boolean isNotificationPolicyAccessGrantedForPackage(String pkg) {
INotificationManager service = getService();
try {
return service.isNotificationPolicyAccessGrantedForPackage(pkg);
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
}
/**
* @hide
*/
public List
*/
public Policy getNotificationPolicy() {
INotificationManager service = getService();
try {
return service.getNotificationPolicy(mContext.getOpPackageName());
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
}
/**
* Sets the current notification policy.
*
*
* Only available if policy access is granted to this package.
* See {@link #isNotificationPolicyAccessGranted}.
*
* @param policy The new desired policy.
*/
public void setNotificationPolicy(@NonNull Policy policy) {
checkRequired("policy", policy);
INotificationManager service = getService();
try {
service.setNotificationPolicy(mContext.getOpPackageName(), policy);
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
}
/** @hide */
public void setNotificationPolicyAccessGranted(String pkg, boolean granted) {
INotificationManager service = getService();
try {
service.setNotificationPolicyAccessGranted(pkg, granted);
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
}
/** @hide */
public void setNotificationListenerAccessGranted(ComponentName listener, boolean granted) {
INotificationManager service = getService();
try {
service.setNotificationListenerAccessGranted(listener, granted);
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
}
/** @hide */
public void setNotificationListenerAccessGrantedForUser(ComponentName listener, int userId,
boolean granted) {
INotificationManager service = getService();
try {
service.setNotificationListenerAccessGrantedForUser(listener, userId, granted);
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
}
/** @hide */
public List
* Apps that target API levels below {@link Build.VERSION_CODES#P} cannot
* change user-designated values to allow or disallow
* {@link Policy#PRIORITY_CATEGORY_ALARMS}, {@link Policy#PRIORITY_CATEGORY_SYSTEM}, and
* {@link Policy#PRIORITY_CATEGORY_MEDIA} from bypassing dnd.
*
* @param priorityCategories bitmask of categories of notifications that can bypass DND.
* @param priorityCallSenders which callers can bypass DND.
* @param priorityMessageSenders which message senders can bypass DND.
*/
public Policy(int priorityCategories, int priorityCallSenders, int priorityMessageSenders) {
this(priorityCategories, priorityCallSenders, priorityMessageSenders,
SUPPRESSED_EFFECTS_UNSET, STATE_UNSET);
}
/**
* Constructs a policy for Do Not Disturb priority mode behavior.
*
*
* Apps that target API levels below {@link Build.VERSION_CODES#P} cannot
* change user-designated values to allow or disallow
* {@link Policy#PRIORITY_CATEGORY_ALARMS}, {@link Policy#PRIORITY_CATEGORY_SYSTEM}, and
* {@link Policy#PRIORITY_CATEGORY_MEDIA} from bypassing dnd.
*
* Additionally, apps that target API levels below {@link Build.VERSION_CODES#P} can
* only modify the {@link #SUPPRESSED_EFFECT_SCREEN_ON} and
* {@link #SUPPRESSED_EFFECT_SCREEN_OFF} bits of the suppressed visual effects field.
* All other suppressed effects will be ignored and reconstituted from the screen on
* and screen off values.
*
* Apps that target {@link Build.VERSION_CODES#P} or above can set any
* suppressed visual effects. However, if any suppressed effects >
* {@link #SUPPRESSED_EFFECT_SCREEN_ON} are set, {@link #SUPPRESSED_EFFECT_SCREEN_ON}
* and {@link #SUPPRESSED_EFFECT_SCREEN_OFF} will be ignored and reconstituted from
* the more specific suppressed visual effect bits. Apps should migrate to targeting
* specific effects instead of the deprecated {@link #SUPPRESSED_EFFECT_SCREEN_ON} and
* {@link #SUPPRESSED_EFFECT_SCREEN_OFF} effects.
*
* @param priorityCategories bitmask of categories of notifications that can bypass DND.
* @param priorityCallSenders which callers can bypass DND.
* @param priorityMessageSenders which message senders can bypass DND.
* @param suppressedVisualEffects which visual interruptions should be suppressed from
* notifications that are filtered by DND.
*/
public Policy(int priorityCategories, int priorityCallSenders, int priorityMessageSenders,
int suppressedVisualEffects) {
this.priorityCategories = priorityCategories;
this.priorityCallSenders = priorityCallSenders;
this.priorityMessageSenders = priorityMessageSenders;
this.suppressedVisualEffects = suppressedVisualEffects;
this.state = STATE_UNSET;
}
/** @hide */
public Policy(int priorityCategories, int priorityCallSenders, int priorityMessageSenders,
int suppressedVisualEffects, int state) {
this.priorityCategories = priorityCategories;
this.priorityCallSenders = priorityCallSenders;
this.priorityMessageSenders = priorityMessageSenders;
this.suppressedVisualEffects = suppressedVisualEffects;
this.state = state;
}
/** @hide */
public Policy(Parcel source) {
this(source.readInt(), source.readInt(), source.readInt(), source.readInt(),
source.readInt());
}
@Override
public void writeToParcel(Parcel dest, int flags) {
dest.writeInt(priorityCategories);
dest.writeInt(priorityCallSenders);
dest.writeInt(priorityMessageSenders);
dest.writeInt(suppressedVisualEffects);
dest.writeInt(state);
}
@Override
public int describeContents() {
return 0;
}
@Override
public int hashCode() {
return Objects.hash(priorityCategories, priorityCallSenders, priorityMessageSenders,
suppressedVisualEffects);
}
@Override
public boolean equals(Object o) {
if (!(o instanceof Policy)) return false;
if (o == this) return true;
final Policy other = (Policy) o;
return other.priorityCategories == priorityCategories
&& other.priorityCallSenders == priorityCallSenders
&& other.priorityMessageSenders == priorityMessageSenders
&& other.suppressedVisualEffects == suppressedVisualEffects;
}
@Override
public String toString() {
return "NotificationManager.Policy["
+ "priorityCategories=" + priorityCategoriesToString(priorityCategories)
+ ",priorityCallSenders=" + prioritySendersToString(priorityCallSenders)
+ ",priorityMessageSenders=" + prioritySendersToString(priorityMessageSenders)
+ ",suppressedVisualEffects="
+ suppressedEffectsToString(suppressedVisualEffects)
+ ",areChannelsBypassingDnd=" + (((state & STATE_CHANNELS_BYPASSING_DND) != 0)
? "true" : "false")
+ "]";
}
/** @hide */
public void writeToProto(ProtoOutputStream proto, long fieldId) {
final long pToken = proto.start(fieldId);
bitwiseToProtoEnum(proto, PolicyProto.PRIORITY_CATEGORIES, priorityCategories);
proto.write(PolicyProto.PRIORITY_CALL_SENDER, priorityCallSenders);
proto.write(PolicyProto.PRIORITY_MESSAGE_SENDER, priorityMessageSenders);
bitwiseToProtoEnum(
proto, PolicyProto.SUPPRESSED_VISUAL_EFFECTS, suppressedVisualEffects);
proto.end(pToken);
}
private static void bitwiseToProtoEnum(ProtoOutputStream proto, long fieldId, int data) {
for (int i = 1; data > 0; ++i, data >>>= 1) {
if ((data & 1) == 1) {
proto.write(fieldId, i);
}
}
}
/**
* @hide
*/
public static int getAllSuppressedVisualEffects() {
int effects = 0;
for (int i = 0; i < ALL_SUPPRESSED_EFFECTS.length; i++) {
effects |= ALL_SUPPRESSED_EFFECTS[i];
}
return effects;
}
/**
* @hide
*/
public static boolean areAllVisualEffectsSuppressed(int effects) {
for (int i = 0; i < ALL_SUPPRESSED_EFFECTS.length; i++) {
final int effect = ALL_SUPPRESSED_EFFECTS[i];
if ((effects & effect) == 0) {
return false;
}
}
return true;
}
/**
* @hide
*/
public static boolean areAnyScreenOffEffectsSuppressed(int effects) {
for (int i = 0; i < SCREEN_OFF_SUPPRESSED_EFFECTS.length; i++) {
final int effect = SCREEN_OFF_SUPPRESSED_EFFECTS[i];
if ((effects & effect) != 0) {
return true;
}
}
return false;
}
/**
* @hide
*/
public static boolean areAnyScreenOnEffectsSuppressed(int effects) {
for (int i = 0; i < SCREEN_ON_SUPPRESSED_EFFECTS.length; i++) {
final int effect = SCREEN_ON_SUPPRESSED_EFFECTS[i];
if ((effects & effect) != 0) {
return true;
}
}
return false;
}
/**
* @hide
*/
public static int toggleScreenOffEffectsSuppressed(int currentEffects, boolean suppress) {
return toggleEffects(currentEffects, SCREEN_OFF_SUPPRESSED_EFFECTS, suppress);
}
/**
* @hide
*/
public static int toggleScreenOnEffectsSuppressed(int currentEffects, boolean suppress) {
return toggleEffects(currentEffects, SCREEN_ON_SUPPRESSED_EFFECTS, suppress);
}
private static int toggleEffects(int currentEffects, int[] effects, boolean suppress) {
for (int i = 0; i < effects.length; i++) {
final int effect = effects[i];
if (suppress) {
currentEffects |= effect;
} else {
currentEffects &= ~effect;
}
}
return currentEffects;
}
public static String suppressedEffectsToString(int effects) {
if (effects <= 0) return "";
final StringBuilder sb = new StringBuilder();
for (int i = 0; i < ALL_SUPPRESSED_EFFECTS.length; i++) {
final int effect = ALL_SUPPRESSED_EFFECTS[i];
if ((effects & effect) != 0) {
if (sb.length() > 0) sb.append(',');
sb.append(effectToString(effect));
}
effects &= ~effect;
}
if (effects != 0) {
if (sb.length() > 0) sb.append(',');
sb.append("UNKNOWN_").append(effects);
}
return sb.toString();
}
public static String priorityCategoriesToString(int priorityCategories) {
if (priorityCategories == 0) return "";
final StringBuilder sb = new StringBuilder();
for (int i = 0; i < ALL_PRIORITY_CATEGORIES.length; i++) {
final int priorityCategory = ALL_PRIORITY_CATEGORIES[i];
if ((priorityCategories & priorityCategory) != 0) {
if (sb.length() > 0) sb.append(',');
sb.append(priorityCategoryToString(priorityCategory));
}
priorityCategories &= ~priorityCategory;
}
if (priorityCategories != 0) {
if (sb.length() > 0) sb.append(',');
sb.append("PRIORITY_CATEGORY_UNKNOWN_").append(priorityCategories);
}
return sb.toString();
}
private static String effectToString(int effect) {
switch (effect) {
case SUPPRESSED_EFFECT_FULL_SCREEN_INTENT:
return "SUPPRESSED_EFFECT_FULL_SCREEN_INTENT";
case SUPPRESSED_EFFECT_LIGHTS:
return "SUPPRESSED_EFFECT_LIGHTS";
case SUPPRESSED_EFFECT_PEEK:
return "SUPPRESSED_EFFECT_PEEK";
case SUPPRESSED_EFFECT_STATUS_BAR:
return "SUPPRESSED_EFFECT_STATUS_BAR";
case SUPPRESSED_EFFECT_BADGE:
return "SUPPRESSED_EFFECT_BADGE";
case SUPPRESSED_EFFECT_AMBIENT:
return "SUPPRESSED_EFFECT_AMBIENT";
case SUPPRESSED_EFFECT_NOTIFICATION_LIST:
return "SUPPRESSED_EFFECT_NOTIFICATION_LIST";
case SUPPRESSED_EFFECT_SCREEN_OFF:
return "SUPPRESSED_EFFECT_SCREEN_OFF";
case SUPPRESSED_EFFECT_SCREEN_ON:
return "SUPPRESSED_EFFECT_SCREEN_ON";
case SUPPRESSED_EFFECTS_UNSET:
return "SUPPRESSED_EFFECTS_UNSET";
default: return "UNKNOWN_" + effect;
}
}
private static String priorityCategoryToString(int priorityCategory) {
switch (priorityCategory) {
case PRIORITY_CATEGORY_REMINDERS: return "PRIORITY_CATEGORY_REMINDERS";
case PRIORITY_CATEGORY_EVENTS: return "PRIORITY_CATEGORY_EVENTS";
case PRIORITY_CATEGORY_MESSAGES: return "PRIORITY_CATEGORY_MESSAGES";
case PRIORITY_CATEGORY_CALLS: return "PRIORITY_CATEGORY_CALLS";
case PRIORITY_CATEGORY_REPEAT_CALLERS: return "PRIORITY_CATEGORY_REPEAT_CALLERS";
case PRIORITY_CATEGORY_ALARMS: return "PRIORITY_CATEGORY_ALARMS";
case PRIORITY_CATEGORY_MEDIA: return "PRIORITY_CATEGORY_MEDIA";
case PRIORITY_CATEGORY_SYSTEM: return "PRIORITY_CATEGORY_SYSTEM";
default: return "PRIORITY_CATEGORY_UNKNOWN_" + priorityCategory;
}
}
public static String prioritySendersToString(int prioritySenders) {
switch (prioritySenders) {
case PRIORITY_SENDERS_ANY: return "PRIORITY_SENDERS_ANY";
case PRIORITY_SENDERS_CONTACTS: return "PRIORITY_SENDERS_CONTACTS";
case PRIORITY_SENDERS_STARRED: return "PRIORITY_SENDERS_STARRED";
default: return "PRIORITY_SENDERS_UNKNOWN_" + prioritySenders;
}
}
public static final Parcelable.Creator
* The interruption filter defines which notifications are allowed to
* interrupt the user (e.g. via sound & vibration) and is applied
* globally.
*/
public final @InterruptionFilter int getCurrentInterruptionFilter() {
final INotificationManager service = getService();
try {
return zenModeToInterruptionFilter(service.getZenMode());
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
}
/**
* Sets the current notification interruption filter.
*
* The interruption filter defines which notifications are allowed to
* interrupt the user (e.g. via sound & vibration) and is applied
* globally.
*
* Only available if policy access is granted to this package. See
* {@link #isNotificationPolicyAccessGranted}.
*/
public final void setInterruptionFilter(@InterruptionFilter int interruptionFilter) {
final INotificationManager service = getService();
try {
service.setInterruptionFilter(mContext.getOpPackageName(), interruptionFilter);
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
}
/** @hide */
public static int zenModeToInterruptionFilter(int zen) {
switch (zen) {
case Global.ZEN_MODE_OFF: return INTERRUPTION_FILTER_ALL;
case Global.ZEN_MODE_IMPORTANT_INTERRUPTIONS: return INTERRUPTION_FILTER_PRIORITY;
case Global.ZEN_MODE_ALARMS: return INTERRUPTION_FILTER_ALARMS;
case Global.ZEN_MODE_NO_INTERRUPTIONS: return INTERRUPTION_FILTER_NONE;
default: return INTERRUPTION_FILTER_UNKNOWN;
}
}
/** @hide */
public static int zenModeFromInterruptionFilter(int interruptionFilter, int defValue) {
switch (interruptionFilter) {
case INTERRUPTION_FILTER_ALL: return Global.ZEN_MODE_OFF;
case INTERRUPTION_FILTER_PRIORITY: return Global.ZEN_MODE_IMPORTANT_INTERRUPTIONS;
case INTERRUPTION_FILTER_ALARMS: return Global.ZEN_MODE_ALARMS;
case INTERRUPTION_FILTER_NONE: return Global.ZEN_MODE_NO_INTERRUPTIONS;
default: return defValue;
}
}
}
tag and id supplied to
* {@link #notify(String, int, Notification) notify()}
* (via {@link StatusBarNotification#getTag() getTag()} and
* {@link StatusBarNotification#getId() getId()}) as well as a copy of the original
* {@link Notification} object (via {@link StatusBarNotification#getNotification()}).
*
* @return An array of {@link StatusBarNotification}.
*/
public StatusBarNotification[] getActiveNotifications() {
final INotificationManager service = getService();
final String pkg = mContext.getPackageName();
try {
final ParceledListSlice