/* * Copyright (C) 2013 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package android.service.notification; import android.annotation.IntDef; import android.annotation.NonNull; import android.annotation.SdkConstant; import android.annotation.SystemApi; import android.app.INotificationManager; import android.app.Notification; import android.app.Notification.Builder; import android.app.NotificationChannel; import android.app.NotificationChannelGroup; import android.app.NotificationManager; import android.app.Service; import android.companion.CompanionDeviceManager; import android.content.ComponentName; import android.content.Context; import android.content.Intent; import android.content.pm.ParceledListSlice; import android.graphics.Bitmap; import android.graphics.drawable.BitmapDrawable; import android.graphics.drawable.Drawable; import android.graphics.drawable.Icon; import android.os.Build; import android.os.Bundle; import android.os.Handler; import android.os.IBinder; import android.os.Looper; import android.os.Message; import android.os.Parcel; import android.os.Parcelable; import android.os.RemoteException; import android.os.ServiceManager; import android.os.UserHandle; import android.util.ArrayMap; import android.util.ArraySet; import android.util.Log; import android.widget.RemoteViews; import com.android.internal.annotations.GuardedBy; import com.android.internal.os.SomeArgs; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.util.ArrayList; import java.util.Collections; import java.util.List; /** * A service that receives calls from the system when new notifications are * posted or removed, or their ranking changed. *
To extend this class, you must declare the service in your manifest file with * the {@link android.Manifest.permission#BIND_NOTIFICATION_LISTENER_SERVICE} permission * and include an intent filter with the {@link #SERVICE_INTERFACE} action. For example:
** <service android:name=".NotificationListener" * android:label="@string/service_name" * android:permission="android.permission.BIND_NOTIFICATION_LISTENER_SERVICE"> * <intent-filter> * <action android:name="android.service.notification.NotificationListenerService" /> * </intent-filter> * </service>* *
The service should wait for the {@link #onListenerConnected()} event * before performing any operations. The {@link #requestRebind(ComponentName)} * method is the only one that is safe to call before {@link #onListenerConnected()} * or after {@link #onListenerDisconnected()}. *
*/ public abstract class NotificationListenerService extends Service { private final String TAG = getClass().getSimpleName(); /** * {@link #getCurrentInterruptionFilter() Interruption filter} constant - * Normal interruption filter. */ public static final int INTERRUPTION_FILTER_ALL = NotificationManager.INTERRUPTION_FILTER_ALL; /** * {@link #getCurrentInterruptionFilter() Interruption filter} constant - * Priority interruption filter. */ public static final int INTERRUPTION_FILTER_PRIORITY = NotificationManager.INTERRUPTION_FILTER_PRIORITY; /** * {@link #getCurrentInterruptionFilter() Interruption filter} constant - * No interruptions filter. */ public static final int INTERRUPTION_FILTER_NONE = NotificationManager.INTERRUPTION_FILTER_NONE; /** * {@link #getCurrentInterruptionFilter() Interruption filter} constant - * Alarms only interruption filter. */ public static final int INTERRUPTION_FILTER_ALARMS = NotificationManager.INTERRUPTION_FILTER_ALARMS; /** {@link #getCurrentInterruptionFilter() Interruption filter} constant - returned when * the value is unavailable for any reason. For example, before the notification listener * is connected. * * {@see #onListenerConnected()} */ public static final int INTERRUPTION_FILTER_UNKNOWN = NotificationManager.INTERRUPTION_FILTER_UNKNOWN; /** {@link #getCurrentListenerHints() Listener hints} constant - the primary device UI * should disable notification sound, vibrating and other visual or aural effects. * This does not change the interruption filter, only the effects. **/ public static final int HINT_HOST_DISABLE_EFFECTS = 1; /** {@link #getCurrentListenerHints() Listener hints} constant - the primary device UI * should disable notification sound, but not phone calls. * This does not change the interruption filter, only the effects. **/ public static final int HINT_HOST_DISABLE_NOTIFICATION_EFFECTS = 1 << 1; /** {@link #getCurrentListenerHints() Listener hints} constant - the primary device UI * should disable phone call sounds, buyt not notification sound. * This does not change the interruption filter, only the effects. **/ public static final int HINT_HOST_DISABLE_CALL_EFFECTS = 1 << 2; /** * Whether notification suppressed by DND should not interruption visually when the screen is * off. */ public static final int SUPPRESSED_EFFECT_SCREEN_OFF = NotificationManager.Policy.SUPPRESSED_EFFECT_SCREEN_OFF; /** * Whether notification suppressed by DND should not interruption visually when the screen is * on. */ public static final int SUPPRESSED_EFFECT_SCREEN_ON = NotificationManager.Policy.SUPPRESSED_EFFECT_SCREEN_ON; // Notification cancellation reasons /** Notification was canceled by the status bar reporting a notification click. */ public static final int REASON_CLICK = 1; /** Notification was canceled by the status bar reporting a user dismissal. */ public static final int REASON_CANCEL = 2; /** Notification was canceled by the status bar reporting a user dismiss all. */ public static final int REASON_CANCEL_ALL = 3; /** Notification was canceled by the status bar reporting an inflation error. */ public static final int REASON_ERROR = 4; /** Notification was canceled by the package manager modifying the package. */ public static final int REASON_PACKAGE_CHANGED = 5; /** Notification was canceled by the owning user context being stopped. */ public static final int REASON_USER_STOPPED = 6; /** Notification was canceled by the user banning the package. */ public static final int REASON_PACKAGE_BANNED = 7; /** Notification was canceled by the app canceling this specific notification. */ public static final int REASON_APP_CANCEL = 8; /** Notification was canceled by the app cancelling all its notifications. */ public static final int REASON_APP_CANCEL_ALL = 9; /** Notification was canceled by a listener reporting a user dismissal. */ public static final int REASON_LISTENER_CANCEL = 10; /** Notification was canceled by a listener reporting a user dismiss all. */ public static final int REASON_LISTENER_CANCEL_ALL = 11; /** Notification was canceled because it was a member of a canceled group. */ public static final int REASON_GROUP_SUMMARY_CANCELED = 12; /** Notification was canceled because it was an invisible member of a group. */ public static final int REASON_GROUP_OPTIMIZATION = 13; /** Notification was canceled by the device administrator suspending the package. */ public static final int REASON_PACKAGE_SUSPENDED = 14; /** Notification was canceled by the owning managed profile being turned off. */ public static final int REASON_PROFILE_TURNED_OFF = 15; /** Autobundled summary notification was canceled because its group was unbundled */ public static final int REASON_UNAUTOBUNDLED = 16; /** Notification was canceled by the user banning the channel. */ public static final int REASON_CHANNEL_BANNED = 17; /** Notification was snoozed. */ public static final int REASON_SNOOZED = 18; /** Notification was canceled due to timeout */ public static final int REASON_TIMEOUT = 19; /** * The full trim of the StatusBarNotification including all its features. * * @hide * @removed */ @SystemApi public static final int TRIM_FULL = 0; /** * A light trim of the StatusBarNotification excluding the following features: * ** This might occur because the user has dismissed the notification using system UI (or another * notification listener) or because the app has withdrawn the notification. *
* NOTE: The {@link StatusBarNotification} object you receive will be "light"; that is, the * result from {@link StatusBarNotification#getNotification} may be missing some heavyweight * fields such as {@link android.app.Notification#contentView} and * {@link android.app.Notification#largeIcon}. However, all other fields on * {@link StatusBarNotification}, sufficient to match this call with a prior call to * {@link #onNotificationPosted(StatusBarNotification)}, will be intact. * * @param sbn A data structure encapsulating at least the original information (tag and id) * and source (package name) used to post the {@link android.app.Notification} that * was just removed. */ public void onNotificationRemoved(StatusBarNotification sbn) { // optional } /** * Implement this method to learn when notifications are removed. *
* This might occur because the user has dismissed the notification using system UI (or another * notification listener) or because the app has withdrawn the notification. *
* NOTE: The {@link StatusBarNotification} object you receive will be "light"; that is, the * result from {@link StatusBarNotification#getNotification} may be missing some heavyweight * fields such as {@link android.app.Notification#contentView} and * {@link android.app.Notification#largeIcon}. However, all other fields on * {@link StatusBarNotification}, sufficient to match this call with a prior call to * {@link #onNotificationPosted(StatusBarNotification)}, will be intact. * * @param sbn A data structure encapsulating at least the original information (tag and id) * and source (package name) used to post the {@link android.app.Notification} that * was just removed. * @param rankingMap The current ranking map that can be used to retrieve ranking information * for active notifications. * */ public void onNotificationRemoved(StatusBarNotification sbn, RankingMap rankingMap) { onNotificationRemoved(sbn); } /** * Implement this method to learn when notifications are removed and why. *
* This might occur because the user has dismissed the notification using system UI (or another * notification listener) or because the app has withdrawn the notification. *
* NOTE: The {@link StatusBarNotification} object you receive will be "light"; that is, the * result from {@link StatusBarNotification#getNotification} may be missing some heavyweight * fields such as {@link android.app.Notification#contentView} and * {@link android.app.Notification#largeIcon}. However, all other fields on * {@link StatusBarNotification}, sufficient to match this call with a prior call to * {@link #onNotificationPosted(StatusBarNotification)}, will be intact. * ** @param sbn A data structure encapsulating at least the original information (tag and id) * and source (package name) used to post the {@link android.app.Notification} that * was just removed. * @param rankingMap The current ranking map that can be used to retrieve ranking information * for active notifications. * @param reason see {@link #REASON_LISTENER_CANCEL}, etc. */ public void onNotificationRemoved(StatusBarNotification sbn, RankingMap rankingMap, int reason) { onNotificationRemoved(sbn, rankingMap); } /** * Implement this method to learn about when the listener is enabled and connected to * the notification manager. You are safe to call {@link #getActiveNotifications()} * at this time. */ public void onListenerConnected() { // optional } /** * Implement this method to learn about when the listener is disconnected from the * notification manager.You will not receive any events after this call, and may only * call {@link #requestRebind(ComponentName)} at this time. */ public void onListenerDisconnected() { // optional } /** * Implement this method to be notified when the notification ranking changes. * * @param rankingMap The current ranking map that can be used to retrieve ranking information * for active notifications. */ public void onNotificationRankingUpdate(RankingMap rankingMap) { // optional } /** * Implement this method to be notified when the * {@link #getCurrentListenerHints() Listener hints} change. * * @param hints The current {@link #getCurrentListenerHints() listener hints}. */ public void onListenerHintsChanged(int hints) { // optional } /** * Implement this method to learn about notification channel modifications. * *
The caller must have {@link CompanionDeviceManager#getAssociations() an associated * device} in order to receive this callback. * * @param pkg The package the channel belongs to. * @param user The user on which the change was made. * @param channel The channel that has changed. * @param modificationType One of {@link #NOTIFICATION_CHANNEL_OR_GROUP_ADDED}, * {@link #NOTIFICATION_CHANNEL_OR_GROUP_UPDATED}, * {@link #NOTIFICATION_CHANNEL_OR_GROUP_DELETED}. */ public void onNotificationChannelModified(String pkg, UserHandle user, NotificationChannel channel, @ChannelOrGroupModificationTypes int modificationType) { // optional } /** * Implement this method to learn about notification channel group modifications. * *
The caller must have {@link CompanionDeviceManager#getAssociations() an associated * device} in order to receive this callback. * * @param pkg The package the group belongs to. * @param user The user on which the change was made. * @param group The group that has changed. * @param modificationType One of {@link #NOTIFICATION_CHANNEL_OR_GROUP_ADDED}, * {@link #NOTIFICATION_CHANNEL_OR_GROUP_UPDATED}, * {@link #NOTIFICATION_CHANNEL_OR_GROUP_DELETED}. */ public void onNotificationChannelGroupModified(String pkg, UserHandle user, NotificationChannelGroup group, @ChannelOrGroupModificationTypes int modificationType) { // optional } /** * Implement this method to be notified when the * {@link #getCurrentInterruptionFilter() interruption filter} changed. * * @param interruptionFilter The current * {@link #getCurrentInterruptionFilter() interruption filter}. */ public void onInterruptionFilterChanged(int interruptionFilter) { // optional } /** @hide */ protected final INotificationManager getNotificationInterface() { if (mNoMan == null) { mNoMan = INotificationManager.Stub.asInterface( ServiceManager.getService(Context.NOTIFICATION_SERVICE)); } return mNoMan; } /** * Inform the notification manager about dismissal of a single notification. *
* Use this if your listener has a user interface that allows the user to dismiss individual * notifications, similar to the behavior of Android's status bar and notification panel. * It should be called after the user dismisses a single notification using your UI; * upon being informed, the notification manager will actually remove the notification * and you will get an {@link #onNotificationRemoved(StatusBarNotification)} callback. *
* Note: If your listener allows the user to fire a notification's * {@link android.app.Notification#contentIntent} by tapping/clicking/etc., you should call * this method at that time if the Notification in question has the * {@link android.app.Notification#FLAG_AUTO_CANCEL} flag set. * *
The service should wait for the {@link #onListenerConnected()} event * before performing this operation. * * @param pkg Package of the notifying app. * @param tag Tag of the notification as specified by the notifying app in * {@link android.app.NotificationManager#notify(String, int, android.app.Notification)}. * @param id ID of the notification as specified by the notifying app in * {@link android.app.NotificationManager#notify(String, int, android.app.Notification)}. *
* @deprecated Use {@link #cancelNotification(String key)} * instead. Beginning with {@link android.os.Build.VERSION_CODES#LOLLIPOP} this method will no longer * cancel the notification. It will continue to cancel the notification for applications * whose {@code targetSdkVersion} is earlier than {@link android.os.Build.VERSION_CODES#LOLLIPOP}. */ @Deprecated public final void cancelNotification(String pkg, String tag, int id) { if (!isBound()) return; try { getNotificationInterface().cancelNotificationFromListener( mWrapper, pkg, tag, id); } catch (android.os.RemoteException ex) { Log.v(TAG, "Unable to contact notification manager", ex); } } /** * Inform the notification manager about dismissal of a single notification. *
* Use this if your listener has a user interface that allows the user to dismiss individual * notifications, similar to the behavior of Android's status bar and notification panel. * It should be called after the user dismisses a single notification using your UI; * upon being informed, the notification manager will actually remove the notification * and you will get an {@link #onNotificationRemoved(StatusBarNotification)} callback. *
* Note: If your listener allows the user to fire a notification's * {@link android.app.Notification#contentIntent} by tapping/clicking/etc., you should call * this method at that time if the Notification in question has the * {@link android.app.Notification#FLAG_AUTO_CANCEL} flag set. *
* *
The service should wait for the {@link #onListenerConnected()} event * before performing this operation. * * @param key Notification to dismiss from {@link StatusBarNotification#getKey()}. */ public final void cancelNotification(String key) { if (!isBound()) return; try { getNotificationInterface().cancelNotificationsFromListener(mWrapper, new String[] { key }); } catch (android.os.RemoteException ex) { Log.v(TAG, "Unable to contact notification manager", ex); } } /** * Inform the notification manager about dismissal of all notifications. *
* Use this if your listener has a user interface that allows the user to dismiss all * notifications, similar to the behavior of Android's status bar and notification panel. * It should be called after the user invokes the "dismiss all" function of your UI; * upon being informed, the notification manager will actually remove all active notifications * and you will get multiple {@link #onNotificationRemoved(StatusBarNotification)} callbacks. * *
The service should wait for the {@link #onListenerConnected()} event * before performing this operation. * * {@see #cancelNotification(String, String, int)} */ public final void cancelAllNotifications() { cancelNotifications(null /*all*/); } /** * Inform the notification manager about dismissal of specific notifications. *
* Use this if your listener has a user interface that allows the user to dismiss * multiple notifications at once. * *
The service should wait for the {@link #onListenerConnected()} event * before performing this operation. * * @param keys Notifications to dismiss, or {@code null} to dismiss all. * * {@see #cancelNotification(String, String, int)} */ public final void cancelNotifications(String[] keys) { if (!isBound()) return; try { getNotificationInterface().cancelNotificationsFromListener(mWrapper, keys); } catch (android.os.RemoteException ex) { Log.v(TAG, "Unable to contact notification manager", ex); } } /** * Inform the notification manager about snoozing a specific notification. *
* Use this if your listener has a user interface that allows the user to snooze a notification * until a given {@link SnoozeCriterion}. It should be called after the user snoozes a single * notification using your UI; upon being informed, the notification manager will actually * remove the notification and you will get an * {@link #onNotificationRemoved(StatusBarNotification)} callback. When the snoozing period * expires, you will get a {@link #onNotificationPosted(StatusBarNotification, RankingMap)} * callback for the notification. * @param key The key of the notification to snooze * @param snoozeCriterionId The{@link SnoozeCriterion#getId()} of a context to snooze the * notification until. * @hide * @removed */ @SystemApi public final void snoozeNotification(String key, String snoozeCriterionId) { if (!isBound()) return; try { getNotificationInterface().snoozeNotificationUntilContextFromListener( mWrapper, key, snoozeCriterionId); } catch (android.os.RemoteException ex) { Log.v(TAG, "Unable to contact notification manager", ex); } } /** * Inform the notification manager about snoozing a specific notification. *
* Use this if your listener has a user interface that allows the user to snooze a notification * for a time. It should be called after the user snoozes a single notification using * your UI; upon being informed, the notification manager will actually remove the notification * and you will get an {@link #onNotificationRemoved(StatusBarNotification)} callback. When the * snoozing period expires, you will get a * {@link #onNotificationPosted(StatusBarNotification, RankingMap)} callback for the * notification. * @param key The key of the notification to snooze * @param durationMs A duration to snooze the notification for, in milliseconds. */ public final void snoozeNotification(String key, long durationMs) { if (!isBound()) return; try { getNotificationInterface().snoozeNotificationUntilFromListener( mWrapper, key, durationMs); } catch (android.os.RemoteException ex) { Log.v(TAG, "Unable to contact notification manager", ex); } } /** * Inform the notification manager that these notifications have been viewed by the * user. This should only be called when there is sufficient confidence that the user is * looking at the notifications, such as when the notifications appear on the screen due to * an explicit user interaction. * *
The service should wait for the {@link #onListenerConnected()} event * before performing this operation. * * @param keys Notifications to mark as seen. */ public final void setNotificationsShown(String[] keys) { if (!isBound()) return; try { getNotificationInterface().setNotificationsShownFromListener(mWrapper, keys); } catch (android.os.RemoteException ex) { Log.v(TAG, "Unable to contact notification manager", ex); } } /** * Updates a notification channel for a given package for a given user. This should only be used * to reflect changes a user has made to the channel via the listener's user interface. * *
This method will throw a security exception if you don't have access to notifications * for the given user.
*The caller must have {@link CompanionDeviceManager#getAssociations() an associated * device} in order to use this method. * * @param pkg The package the channel belongs to. * @param user The user the channel belongs to. * @param channel the channel to update. */ public final void updateNotificationChannel(@NonNull String pkg, @NonNull UserHandle user, @NonNull NotificationChannel channel) { if (!isBound()) return; try { getNotificationInterface().updateNotificationChannelFromPrivilegedListener( mWrapper, pkg, user, channel); } catch (RemoteException e) { Log.v(TAG, "Unable to contact notification manager", e); throw e.rethrowFromSystemServer(); } } /** * Returns all notification channels belonging to the given package for a given user. * *
This method will throw a security exception if you don't have access to notifications * for the given user.
*The caller must have {@link CompanionDeviceManager#getAssociations() an associated
* device} in order to use this method.
*
* @param pkg The package to retrieve channels for.
*/
public final List This method will throw a security exception if you don't have access to notifications
* for the given user. The caller must have {@link CompanionDeviceManager#getAssociations() an associated
* device} in order to use this method.
*
* @param pkg The package to retrieve channel groups for.
*/
public final List
* Setting a trim other than {@link #TRIM_FULL} enables listeners that don't need access to the
* full notification features right away to reduce their memory footprint. Full notifications
* can be requested on-demand via {@link #getActiveNotifications(int)}.
*
*
* Set to {@link #TRIM_FULL} initially.
*
* The service should wait for the {@link #onListenerConnected()} event
* before performing this operation.
*
* @hide
* @removed
*
* @param trim trim of the notifications to be passed via {@link #onNotificationPosted}.
* See The service should wait for the {@link #onListenerConnected()} event
* before performing this operation.
*
* @return An array of active notifications, sorted in natural order.
*/
public StatusBarNotification[] getActiveNotifications() {
return getActiveNotifications(null, TRIM_FULL);
}
/**
* Like {@link #getActiveNotifications()}, but returns the list of currently snoozed
* notifications, for all users this listener has access to.
*
* The service should wait for the {@link #onListenerConnected()} event
* before performing this operation.
*
* @return An array of snoozed notifications, sorted in natural order.
*/
public final StatusBarNotification[] getSnoozedNotifications() {
try {
ParceledListSlice The service should wait for the {@link #onListenerConnected()} event
* before performing this operation.
*
* @param keys the keys of the notifications to request
* @return An array of notifications corresponding to the requested keys, in the
* same order as the key list.
*/
public StatusBarNotification[] getActiveNotifications(String[] keys) {
return getActiveNotifications(keys, TRIM_FULL);
}
/**
* Request one or more notifications by key. Useful if you have been keeping track of
* notifications but didn't want to retain the bits, and now need to go back and extract
* more data out of those notifications.
*
* @hide
* @removed
*
* @param keys the keys of the notifications to request
* @param trim trim of the notifications to be returned. See
* The current state may differ from the requested state if the hint represents state
* shared across all listeners or a feature the notification host does not support or refuses
* to grant.
*
* The service should wait for the {@link #onListenerConnected()} event
* before performing this operation.
*
* @return Zero or more of the HINT_ constants.
*/
public final int getCurrentListenerHints() {
if (!isBound()) return 0;
try {
return getNotificationInterface().getHintsFromListener(mWrapper);
} catch (android.os.RemoteException ex) {
Log.v(TAG, "Unable to contact notification manager", ex);
return 0;
}
}
/**
* Gets the current notification interruption filter active on the host.
*
*
* The interruption filter defines which notifications are allowed to interrupt the user
* (e.g. via sound & vibration) and is applied globally. Listeners can find out whether
* a specific notification matched the interruption filter via
* {@link Ranking#matchesInterruptionFilter()}.
*
* The current filter may differ from the previously requested filter if the notification host
* does not support or refuses to apply the requested filter, or if another component changed
* the filter in the meantime.
*
* Listen for updates using {@link #onInterruptionFilterChanged(int)}.
*
* The service should wait for the {@link #onListenerConnected()} event
* before performing this operation.
*
* @return One of the INTERRUPTION_FILTER_ constants, or INTERRUPTION_FILTER_UNKNOWN when
* unavailable.
*/
public final int getCurrentInterruptionFilter() {
if (!isBound()) return INTERRUPTION_FILTER_UNKNOWN;
try {
return getNotificationInterface().getInterruptionFilterFromListener(mWrapper);
} catch (android.os.RemoteException ex) {
Log.v(TAG, "Unable to contact notification manager", ex);
return INTERRUPTION_FILTER_UNKNOWN;
}
}
/**
* Sets the desired {@link #getCurrentListenerHints() listener hints}.
*
*
* This is merely a request, the host may or may not choose to take action depending
* on other listener requests or other global state.
*
* Listen for updates using {@link #onListenerHintsChanged(int)}.
*
* The service should wait for the {@link #onListenerConnected()} event
* before performing this operation.
*
* @param hints One or more of the HINT_ constants.
*/
public final void requestListenerHints(int hints) {
if (!isBound()) return;
try {
getNotificationInterface().requestHintsFromListener(mWrapper, hints);
} catch (android.os.RemoteException ex) {
Log.v(TAG, "Unable to contact notification manager", ex);
}
}
/**
* Sets the desired {@link #getCurrentInterruptionFilter() interruption filter}.
*
*
* This is merely a request, the host may or may not choose to apply the requested
* interruption filter depending on other listener requests or other global state.
*
* Listen for updates using {@link #onInterruptionFilterChanged(int)}.
*
* The service should wait for the {@link #onListenerConnected()} event
* before performing this operation.
*
* @param interruptionFilter One of the INTERRUPTION_FILTER_ constants.
*/
public final void requestInterruptionFilter(int interruptionFilter) {
if (!isBound()) return;
try {
getNotificationInterface()
.requestInterruptionFilterFromListener(mWrapper, interruptionFilter);
} catch (android.os.RemoteException ex) {
Log.v(TAG, "Unable to contact notification manager", ex);
}
}
/**
* Returns current ranking information.
*
*
* The returned object represents the current ranking snapshot and only
* applies for currently active notifications.
*
* Generally you should use the RankingMap that is passed with events such
* as {@link #onNotificationPosted(StatusBarNotification, RankingMap)},
* {@link #onNotificationRemoved(StatusBarNotification, RankingMap)}, and
* so on. This method should only be used when needing access outside of
* such events, for example to retrieve the RankingMap right after
* initialization.
*
* The service should wait for the {@link #onListenerConnected()} event
* before performing this operation.
*
* @return A {@link RankingMap} object providing access to ranking information
*/
public RankingMap getCurrentRanking() {
synchronized (mLock) {
return mRankingMap;
}
}
/**
* This is not the lifecycle event you are looking for.
*
* The service should wait for the {@link #onListenerConnected()} event
* before performing any operations.
*/
@Override
public IBinder onBind(Intent intent) {
if (mWrapper == null) {
mWrapper = new NotificationListenerWrapper();
}
return mWrapper;
}
/** @hide */
protected boolean isBound() {
if (mWrapper == null) {
Log.w(TAG, "Notification listener service not yet bound.");
return false;
}
return true;
}
@Override
public void onDestroy() {
onListenerDisconnected();
super.onDestroy();
}
/**
* Directly register this service with the Notification Manager.
*
* Only system services may use this call. It will fail for non-system callers.
* Apps should ask the user to add their listener in Settings.
*
* @param context Context required for accessing resources. Since this service isn't
* launched as a real Service when using this method, a context has to be passed in.
* @param componentName the component that will consume the notification information
* @param currentUser the user to use as the stream filter
* @hide
* @removed
*/
@SystemApi
public void registerAsSystemService(Context context, ComponentName componentName,
int currentUser) throws RemoteException {
if (mWrapper == null) {
mWrapper = new NotificationListenerWrapper();
}
mSystemContext = context;
INotificationManager noMan = getNotificationInterface();
mHandler = new MyHandler(context.getMainLooper());
mCurrentUser = currentUser;
noMan.registerListener(mWrapper, componentName, currentUser);
}
/**
* Directly unregister this service from the Notification Manager.
*
* This method will fail for listeners that were not registered
* with (@link registerAsService).
* @hide
* @removed
*/
@SystemApi
public void unregisterAsSystemService() throws RemoteException {
if (mWrapper != null) {
INotificationManager noMan = getNotificationInterface();
noMan.unregisterListener(mWrapper, mCurrentUser);
}
}
/**
* Request that the listener be rebound, after a previous call to {@link #requestUnbind}.
*
* This method will fail for listeners that have
* not been granted the permission by the user.
*/
public static void requestRebind(ComponentName componentName) {
INotificationManager noMan = INotificationManager.Stub.asInterface(
ServiceManager.getService(Context.NOTIFICATION_SERVICE));
try {
noMan.requestBindListener(componentName);
} catch (RemoteException ex) {
throw ex.rethrowFromSystemServer();
}
}
/**
* Request that the service be unbound.
*
* Once this is called, you will no longer receive updates and no method calls are
* guaranteed to be successful, until you next receive the {@link #onListenerConnected()} event.
* The service will likely be killed by the system after this call.
*
* The service should wait for the {@link #onListenerConnected()} event
* before performing this operation. I know it's tempting, but you must wait.
*/
public final void requestUnbind() {
if (mWrapper != null) {
INotificationManager noMan = getNotificationInterface();
try {
noMan.requestUnbindListener(mWrapper);
// Disable future messages.
isConnected = false;
} catch (RemoteException ex) {
throw ex.rethrowFromSystemServer();
}
}
}
/** Convert new-style Icons to legacy representations for pre-M clients. */
private void createLegacyIconExtras(Notification n) {
Icon smallIcon = n.getSmallIcon();
Icon largeIcon = n.getLargeIcon();
if (smallIcon != null && smallIcon.getType() == Icon.TYPE_RESOURCE) {
n.extras.putInt(Notification.EXTRA_SMALL_ICON, smallIcon.getResId());
n.icon = smallIcon.getResId();
}
if (largeIcon != null) {
Drawable d = largeIcon.loadDrawable(getContext());
if (d != null && d instanceof BitmapDrawable) {
final Bitmap largeIconBits = ((BitmapDrawable) d).getBitmap();
n.extras.putParcelable(Notification.EXTRA_LARGE_ICON, largeIconBits);
n.largeIcon = largeIconBits;
}
}
}
/**
* Populates remote views for pre-N targeting apps.
*/
private void maybePopulateRemoteViews(Notification notification) {
if (getContext().getApplicationInfo().targetSdkVersion < Build.VERSION_CODES.N) {
Builder builder = Builder.recoverBuilder(getContext(), notification);
// Some styles wrap Notification's contentView, bigContentView and headsUpContentView.
// First inflate them all, only then set them to avoid recursive wrapping.
RemoteViews content = builder.createContentView();
RemoteViews big = builder.createBigContentView();
RemoteViews headsUp = builder.createHeadsUpContentView();
notification.contentView = content;
notification.bigContentView = big;
notification.headsUpContentView = headsUp;
}
}
/** @hide */
protected class NotificationListenerWrapper extends INotificationListener.Stub {
@Override
public void onNotificationPosted(IStatusBarNotificationHolder sbnHolder,
NotificationRankingUpdate update) {
StatusBarNotification sbn;
try {
sbn = sbnHolder.get();
} catch (RemoteException e) {
Log.w(TAG, "onNotificationPosted: Error receiving StatusBarNotification", e);
return;
}
try {
// convert icon metadata to legacy format for older clients
createLegacyIconExtras(sbn.getNotification());
maybePopulateRemoteViews(sbn.getNotification());
} catch (IllegalArgumentException e) {
// warn and drop corrupt notification
Log.w(TAG, "onNotificationPosted: can't rebuild notification from " +
sbn.getPackageName());
sbn = null;
}
// protect subclass from concurrent modifications of (@link mNotificationKeys}.
synchronized (mLock) {
applyUpdateLocked(update);
if (sbn != null) {
SomeArgs args = SomeArgs.obtain();
args.arg1 = sbn;
args.arg2 = mRankingMap;
mHandler.obtainMessage(MyHandler.MSG_ON_NOTIFICATION_POSTED,
args).sendToTarget();
} else {
// still pass along the ranking map, it may contain other information
mHandler.obtainMessage(MyHandler.MSG_ON_NOTIFICATION_RANKING_UPDATE,
mRankingMap).sendToTarget();
}
}
}
@Override
public void onNotificationRemoved(IStatusBarNotificationHolder sbnHolder,
NotificationRankingUpdate update, int reason) {
StatusBarNotification sbn;
try {
sbn = sbnHolder.get();
} catch (RemoteException e) {
Log.w(TAG, "onNotificationRemoved: Error receiving StatusBarNotification", e);
return;
}
// protect subclass from concurrent modifications of (@link mNotificationKeys}.
synchronized (mLock) {
applyUpdateLocked(update);
SomeArgs args = SomeArgs.obtain();
args.arg1 = sbn;
args.arg2 = mRankingMap;
args.arg3 = reason;
mHandler.obtainMessage(MyHandler.MSG_ON_NOTIFICATION_REMOVED,
args).sendToTarget();
}
}
@Override
public void onListenerConnected(NotificationRankingUpdate update) {
// protect subclass from concurrent modifications of (@link mNotificationKeys}.
synchronized (mLock) {
applyUpdateLocked(update);
}
isConnected = true;
mHandler.obtainMessage(MyHandler.MSG_ON_LISTENER_CONNECTED).sendToTarget();
}
@Override
public void onNotificationRankingUpdate(NotificationRankingUpdate update)
throws RemoteException {
// protect subclass from concurrent modifications of (@link mNotificationKeys}.
synchronized (mLock) {
applyUpdateLocked(update);
mHandler.obtainMessage(MyHandler.MSG_ON_NOTIFICATION_RANKING_UPDATE,
mRankingMap).sendToTarget();
}
}
@Override
public void onListenerHintsChanged(int hints) throws RemoteException {
mHandler.obtainMessage(MyHandler.MSG_ON_LISTENER_HINTS_CHANGED,
hints, 0).sendToTarget();
}
@Override
public void onInterruptionFilterChanged(int interruptionFilter) throws RemoteException {
mHandler.obtainMessage(MyHandler.MSG_ON_INTERRUPTION_FILTER_CHANGED,
interruptionFilter, 0).sendToTarget();
}
@Override
public void onNotificationEnqueued(IStatusBarNotificationHolder notificationHolder)
throws RemoteException {
// no-op in the listener
}
@Override
public void onNotificationSnoozedUntilContext(
IStatusBarNotificationHolder notificationHolder, String snoozeCriterionId)
throws RemoteException {
// no-op in the listener
}
@Override
public void onNotificationChannelModification(String pkgName, UserHandle user,
NotificationChannel channel,
@ChannelOrGroupModificationTypes int modificationType) {
SomeArgs args = SomeArgs.obtain();
args.arg1 = pkgName;
args.arg2 = user;
args.arg3 = channel;
args.arg4 = modificationType;
mHandler.obtainMessage(
MyHandler.MSG_ON_NOTIFICATION_CHANNEL_MODIFIED, args).sendToTarget();
}
@Override
public void onNotificationChannelGroupModification(String pkgName, UserHandle user,
NotificationChannelGroup group,
@ChannelOrGroupModificationTypes int modificationType) {
SomeArgs args = SomeArgs.obtain();
args.arg1 = pkgName;
args.arg2 = user;
args.arg3 = group;
args.arg4 = modificationType;
mHandler.obtainMessage(
MyHandler.MSG_ON_NOTIFICATION_CHANNEL_GROUP_MODIFIED, args).sendToTarget();
}
}
/**
* @hide
*/
public final void applyUpdateLocked(NotificationRankingUpdate update) {
mRankingMap = new RankingMap(update);
}
/** @hide */
protected Context getContext() {
if (mSystemContext != null) {
return mSystemContext;
}
return this;
}
/**
* Stores ranking related information on a currently active notification.
*
*
* Ranking objects aren't automatically updated as notification events
* occur. Instead, ranking information has to be retrieved again via the
* current {@link RankingMap}.
*/
public static class Ranking {
/** Value signifying that the user has not expressed a per-app visibility override value.
* @hide */
public static final int VISIBILITY_NO_OVERRIDE = NotificationManager.VISIBILITY_NO_OVERRIDE;
private String mKey;
private int mRank = -1;
private boolean mIsAmbient;
private boolean mMatchesInterruptionFilter;
private int mVisibilityOverride;
private int mSuppressedVisualEffects;
private @NotificationManager.Importance int mImportance;
private CharSequence mImportanceExplanation;
// System specified group key.
private String mOverrideGroupKey;
// Notification assistant channel override.
private NotificationChannel mChannel;
// Notification assistant people override.
private ArrayList
* Note that this object represents a ranking snapshot that only applies to
* notifications active at the time of retrieval.
*/
public static class RankingMap implements Parcelable {
private final NotificationRankingUpdate mRankingUpdate;
private ArrayMapTRIM_*
constants.
*/
@SystemApi
public final void setOnNotificationPostedTrim(int trim) {
if (!isBound()) return;
try {
getNotificationInterface().setOnNotificationPostedTrimFromListener(mWrapper, trim);
} catch (RemoteException ex) {
Log.v(TAG, "Unable to contact notification manager", ex);
}
}
/**
* Request the list of outstanding notifications (that is, those that are visible to the
* current user). Useful when you don't know what's already been posted.
*
* TRIM_*
constants.
* @return An array of active notifications, sorted in natural order.
*/
@SystemApi
public StatusBarNotification[] getActiveNotifications(int trim) {
return getActiveNotifications(null, trim);
}
/**
* Request one or more notifications by key. Useful if you have been keeping track of
* notifications but didn't want to retain the bits, and now need to go back and extract
* more data out of those notifications.
*
* TRIM_*
constants.
* @return An array of notifications corresponding to the requested keys, in the
* same order as the key list.
*/
@SystemApi
public StatusBarNotification[] getActiveNotifications(String[] keys, int trim) {
if (!isBound())
return null;
try {
ParceledListSlice