* 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.
* 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 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 read/modify notification policy for the calling package.
*
*
* Returns true if the calling package can read/modify notification policy.
*
*
* 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();
}
}
/** @hide */
public boolean isNotificationPolicyAccessGrantedForPackage(String pkg) {
INotificationManager service = getService();
try {
return service.isNotificationPolicyAccessGrantedForPackage(pkg);
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
}
/**
* Gets the current notification policy.
*
*
* Only available if policy access is granted to this package.
* See {@link #isNotificationPolicyAccessGranted}.
*/
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 ArraySet
* 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