| /* |
| * Copyright (C) 2014 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 androidx.core.app; |
| |
| import android.app.AppOpsManager; |
| import android.app.Notification; |
| import android.app.NotificationManager; |
| import android.app.Service; |
| import android.content.ComponentName; |
| import android.content.Context; |
| import android.content.Intent; |
| import android.content.ServiceConnection; |
| import android.content.pm.ApplicationInfo; |
| import android.content.pm.ResolveInfo; |
| import android.os.Build; |
| import android.os.Bundle; |
| import android.os.DeadObjectException; |
| import android.os.Handler; |
| import android.os.HandlerThread; |
| import android.os.IBinder; |
| import android.os.Message; |
| import android.os.RemoteException; |
| import android.provider.Settings; |
| import android.support.v4.app.INotificationSideChannel; |
| import android.util.Log; |
| |
| import androidx.annotation.GuardedBy; |
| import androidx.annotation.NonNull; |
| import androidx.annotation.Nullable; |
| |
| import java.lang.reflect.Field; |
| import java.lang.reflect.InvocationTargetException; |
| import java.lang.reflect.Method; |
| import java.util.ArrayDeque; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| |
| /** |
| * Compatibility library for NotificationManager with fallbacks for older platforms. |
| * |
| * <p>To use this class, call the static function {@link #from} to get a |
| * {@link NotificationManagerCompat} object, and then call one of its |
| * methods to post or cancel notifications. |
| */ |
| public final class NotificationManagerCompat { |
| private static final String TAG = "NotifManCompat"; |
| private static final String CHECK_OP_NO_THROW = "checkOpNoThrow"; |
| private static final String OP_POST_NOTIFICATION = "OP_POST_NOTIFICATION"; |
| |
| /** |
| * Notification extras key: if set to true, the posted notification should use |
| * the side channel for delivery instead of using notification manager. |
| */ |
| public static final String EXTRA_USE_SIDE_CHANNEL = "android.support.useSideChannel"; |
| |
| /** |
| * Intent action to register for on a service to receive side channel |
| * notifications. The listening service must be in the same package as an enabled |
| * {@link android.service.notification.NotificationListenerService}. |
| */ |
| public static final String ACTION_BIND_SIDE_CHANNEL = |
| "android.support.BIND_NOTIFICATION_SIDE_CHANNEL"; |
| |
| /** |
| * Maximum sdk build version which needs support for side channeled notifications. |
| * Currently the only needed use is for side channeling group children before KITKAT_WATCH. |
| */ |
| static final int MAX_SIDE_CHANNEL_SDK_VERSION = 19; |
| |
| /** Base time delay for a side channel listener queue retry. */ |
| private static final int SIDE_CHANNEL_RETRY_BASE_INTERVAL_MS = 1000; |
| /** Maximum retries for a side channel listener before dropping tasks. */ |
| private static final int SIDE_CHANNEL_RETRY_MAX_COUNT = 6; |
| /** Hidden field Settings.Secure.ENABLED_NOTIFICATION_LISTENERS */ |
| private static final String SETTING_ENABLED_NOTIFICATION_LISTENERS = |
| "enabled_notification_listeners"; |
| |
| /** Cache of enabled notification listener components */ |
| private static final Object sEnabledNotificationListenersLock = new Object(); |
| @GuardedBy("sEnabledNotificationListenersLock") |
| private static String sEnabledNotificationListeners; |
| @GuardedBy("sEnabledNotificationListenersLock") |
| private static Set<String> sEnabledNotificationListenerPackages = new HashSet<String>(); |
| |
| private final Context mContext; |
| private final NotificationManager mNotificationManager; |
| /** Lock for mutable static fields */ |
| private static final Object sLock = new Object(); |
| @GuardedBy("sLock") |
| private static SideChannelManager sSideChannelManager; |
| |
| /** |
| * Value signifying that the user has not expressed an importance. |
| * |
| * This value is for persisting preferences, and should never be associated with |
| * an actual notification. |
| */ |
| public static final int IMPORTANCE_UNSPECIFIED = -1000; |
| |
| /** |
| * A notification with no importance: shows nowhere, is blocked. |
| */ |
| public static final int IMPORTANCE_NONE = 0; |
| |
| /** |
| * Min notification importance: only shows in the shade, below the fold. |
| */ |
| public static final int IMPORTANCE_MIN = 1; |
| |
| /** |
| * Low notification importance: shows everywhere, but is not intrusive. |
| */ |
| public static final int IMPORTANCE_LOW = 2; |
| |
| /** |
| * Default notification importance: shows everywhere, allowed to makes noise, |
| * but does not visually intrude. |
| */ |
| public static final int IMPORTANCE_DEFAULT = 3; |
| |
| /** |
| * Higher notification importance: shows everywhere, allowed to makes noise and peek. |
| */ |
| public static final int IMPORTANCE_HIGH = 4; |
| |
| /** |
| * Highest notification importance: shows everywhere, allowed to makes noise, peek, and |
| * use full screen intents. |
| */ |
| public static final int IMPORTANCE_MAX = 5; |
| |
| /** Get a {@link NotificationManagerCompat} instance for a provided context. */ |
| @NonNull |
| public static NotificationManagerCompat from(@NonNull Context context) { |
| return new NotificationManagerCompat(context); |
| } |
| |
| private NotificationManagerCompat(Context context) { |
| mContext = context; |
| mNotificationManager = (NotificationManager) mContext.getSystemService( |
| Context.NOTIFICATION_SERVICE); |
| } |
| |
| /** |
| * Cancel a previously shown notification. |
| * @param id the ID of the notification |
| */ |
| public void cancel(int id) { |
| cancel(null, id); |
| } |
| |
| /** |
| * Cancel a previously shown notification. |
| * @param tag the string identifier of the notification. |
| * @param id the ID of the notification |
| */ |
| public void cancel(@Nullable String tag, int id) { |
| mNotificationManager.cancel(tag, id); |
| if (Build.VERSION.SDK_INT <= MAX_SIDE_CHANNEL_SDK_VERSION) { |
| pushSideChannelQueue(new CancelTask(mContext.getPackageName(), id, tag)); |
| } |
| } |
| |
| /** Cancel all previously shown notifications. */ |
| public void cancelAll() { |
| mNotificationManager.cancelAll(); |
| if (Build.VERSION.SDK_INT <= MAX_SIDE_CHANNEL_SDK_VERSION) { |
| pushSideChannelQueue(new CancelTask(mContext.getPackageName())); |
| } |
| } |
| |
| /** |
| * Post a notification to be shown in the status bar, stream, etc. |
| * @param id the ID of the notification |
| * @param notification the notification to post to the system |
| */ |
| public void notify(int id, @NonNull Notification notification) { |
| notify(null, id, notification); |
| } |
| |
| /** |
| * Post a notification to be shown in the status bar, stream, etc. |
| * @param tag the string identifier for a notification. Can be {@code null}. |
| * @param id the ID of the notification. The pair (tag, id) must be unique within your app. |
| * @param notification the notification to post to the system |
| */ |
| public void notify(@Nullable String tag, int id, @NonNull Notification notification) { |
| if (useSideChannelForNotification(notification)) { |
| pushSideChannelQueue(new NotifyTask(mContext.getPackageName(), id, tag, notification)); |
| // Cancel this notification in notification manager if it just transitioned to being |
| // side channelled. |
| mNotificationManager.cancel(tag, id); |
| } else { |
| mNotificationManager.notify(tag, id, notification); |
| } |
| } |
| |
| /** |
| * Returns whether notifications from the calling package are not blocked. |
| */ |
| public boolean areNotificationsEnabled() { |
| if (Build.VERSION.SDK_INT >= 24) { |
| return mNotificationManager.areNotificationsEnabled(); |
| } else if (Build.VERSION.SDK_INT >= 19) { |
| AppOpsManager appOps = |
| (AppOpsManager) mContext.getSystemService(Context.APP_OPS_SERVICE); |
| ApplicationInfo appInfo = mContext.getApplicationInfo(); |
| String pkg = mContext.getApplicationContext().getPackageName(); |
| int uid = appInfo.uid; |
| try { |
| Class<?> appOpsClass = Class.forName(AppOpsManager.class.getName()); |
| Method checkOpNoThrowMethod = appOpsClass.getMethod(CHECK_OP_NO_THROW, Integer.TYPE, |
| Integer.TYPE, String.class); |
| Field opPostNotificationValue = appOpsClass.getDeclaredField(OP_POST_NOTIFICATION); |
| int value = (int) opPostNotificationValue.get(Integer.class); |
| return ((int) checkOpNoThrowMethod.invoke(appOps, value, uid, pkg) |
| == AppOpsManager.MODE_ALLOWED); |
| } catch (ClassNotFoundException | NoSuchMethodException | NoSuchFieldException |
| | InvocationTargetException | IllegalAccessException | RuntimeException e) { |
| return true; |
| } |
| } else { |
| return true; |
| } |
| } |
| |
| /** |
| * Returns the user specified importance for notifications from the calling package. |
| * |
| * @return An importance level, such as {@link #IMPORTANCE_DEFAULT}. |
| */ |
| public int getImportance() { |
| if (Build.VERSION.SDK_INT >= 24) { |
| return mNotificationManager.getImportance(); |
| } else { |
| return IMPORTANCE_UNSPECIFIED; |
| } |
| } |
| |
| /** |
| * Get the set of packages that have an enabled notification listener component within them. |
| */ |
| @NonNull |
| public static Set<String> getEnabledListenerPackages(@NonNull Context context) { |
| final String enabledNotificationListeners = Settings.Secure.getString( |
| context.getContentResolver(), |
| SETTING_ENABLED_NOTIFICATION_LISTENERS); |
| synchronized (sEnabledNotificationListenersLock) { |
| // Parse the string again if it is different from the last time this method was called. |
| if (enabledNotificationListeners != null |
| && !enabledNotificationListeners.equals(sEnabledNotificationListeners)) { |
| final String[] components = enabledNotificationListeners.split(":"); |
| Set<String> packageNames = new HashSet<String>(components.length); |
| for (String component : components) { |
| ComponentName componentName = ComponentName.unflattenFromString(component); |
| if (componentName != null) { |
| packageNames.add(componentName.getPackageName()); |
| } |
| } |
| sEnabledNotificationListenerPackages = packageNames; |
| sEnabledNotificationListeners = enabledNotificationListeners; |
| } |
| return sEnabledNotificationListenerPackages; |
| } |
| } |
| |
| /** |
| * Returns true if this notification should use the side channel for delivery. |
| */ |
| private static boolean useSideChannelForNotification(Notification notification) { |
| Bundle extras = NotificationCompat.getExtras(notification); |
| return extras != null && extras.getBoolean(EXTRA_USE_SIDE_CHANNEL); |
| } |
| |
| /** |
| * Push a notification task for distribution to notification side channels. |
| */ |
| private void pushSideChannelQueue(Task task) { |
| synchronized (sLock) { |
| if (sSideChannelManager == null) { |
| sSideChannelManager = new SideChannelManager(mContext.getApplicationContext()); |
| } |
| sSideChannelManager.queueTask(task); |
| } |
| } |
| |
| /** |
| * Helper class to manage a queue of pending tasks to send to notification side channel |
| * listeners. |
| */ |
| private static class SideChannelManager implements Handler.Callback, ServiceConnection { |
| private static final int MSG_QUEUE_TASK = 0; |
| private static final int MSG_SERVICE_CONNECTED = 1; |
| private static final int MSG_SERVICE_DISCONNECTED = 2; |
| private static final int MSG_RETRY_LISTENER_QUEUE = 3; |
| |
| private final Context mContext; |
| private final HandlerThread mHandlerThread; |
| private final Handler mHandler; |
| private final Map<ComponentName, ListenerRecord> mRecordMap = |
| new HashMap<ComponentName, ListenerRecord>(); |
| private Set<String> mCachedEnabledPackages = new HashSet<String>(); |
| |
| SideChannelManager(Context context) { |
| mContext = context; |
| mHandlerThread = new HandlerThread("NotificationManagerCompat"); |
| mHandlerThread.start(); |
| mHandler = new Handler(mHandlerThread.getLooper(), this); |
| } |
| |
| /** |
| * Queue a new task to be sent to all listeners. This function can be called |
| * from any thread. |
| */ |
| public void queueTask(Task task) { |
| mHandler.obtainMessage(MSG_QUEUE_TASK, task).sendToTarget(); |
| } |
| |
| @Override |
| public boolean handleMessage(Message msg) { |
| switch (msg.what) { |
| case MSG_QUEUE_TASK: |
| handleQueueTask((Task) msg.obj); |
| return true; |
| case MSG_SERVICE_CONNECTED: |
| ServiceConnectedEvent event = (ServiceConnectedEvent) msg.obj; |
| handleServiceConnected(event.componentName, event.iBinder); |
| return true; |
| case MSG_SERVICE_DISCONNECTED: |
| handleServiceDisconnected((ComponentName) msg.obj); |
| return true; |
| case MSG_RETRY_LISTENER_QUEUE: |
| handleRetryListenerQueue((ComponentName) msg.obj); |
| return true; |
| } |
| return false; |
| } |
| |
| private void handleQueueTask(Task task) { |
| updateListenerMap(); |
| for (ListenerRecord record : mRecordMap.values()) { |
| record.taskQueue.add(task); |
| processListenerQueue(record); |
| } |
| } |
| |
| private void handleServiceConnected(ComponentName componentName, IBinder iBinder) { |
| ListenerRecord record = mRecordMap.get(componentName); |
| if (record != null) { |
| record.service = INotificationSideChannel.Stub.asInterface(iBinder); |
| record.retryCount = 0; |
| processListenerQueue(record); |
| } |
| } |
| |
| private void handleServiceDisconnected(ComponentName componentName) { |
| ListenerRecord record = mRecordMap.get(componentName); |
| if (record != null) { |
| ensureServiceUnbound(record); |
| } |
| } |
| |
| private void handleRetryListenerQueue(ComponentName componentName) { |
| ListenerRecord record = mRecordMap.get(componentName); |
| if (record != null) { |
| processListenerQueue(record); |
| } |
| } |
| |
| @Override |
| public void onServiceConnected(ComponentName componentName, IBinder iBinder) { |
| if (Log.isLoggable(TAG, Log.DEBUG)) { |
| Log.d(TAG, "Connected to service " + componentName); |
| } |
| mHandler.obtainMessage(MSG_SERVICE_CONNECTED, |
| new ServiceConnectedEvent(componentName, iBinder)) |
| .sendToTarget(); |
| } |
| |
| @Override |
| public void onServiceDisconnected(ComponentName componentName) { |
| if (Log.isLoggable(TAG, Log.DEBUG)) { |
| Log.d(TAG, "Disconnected from service " + componentName); |
| } |
| mHandler.obtainMessage(MSG_SERVICE_DISCONNECTED, componentName).sendToTarget(); |
| } |
| |
| /** |
| * Check the current list of enabled listener packages and update the records map |
| * accordingly. |
| */ |
| private void updateListenerMap() { |
| Set<String> enabledPackages = getEnabledListenerPackages(mContext); |
| if (enabledPackages.equals(mCachedEnabledPackages)) { |
| // Short-circuit when the list of enabled packages has not changed. |
| return; |
| } |
| mCachedEnabledPackages = enabledPackages; |
| List<ResolveInfo> resolveInfos = mContext.getPackageManager().queryIntentServices( |
| new Intent().setAction(ACTION_BIND_SIDE_CHANNEL), 0); |
| Set<ComponentName> enabledComponents = new HashSet<ComponentName>(); |
| for (ResolveInfo resolveInfo : resolveInfos) { |
| if (!enabledPackages.contains(resolveInfo.serviceInfo.packageName)) { |
| continue; |
| } |
| ComponentName componentName = new ComponentName( |
| resolveInfo.serviceInfo.packageName, resolveInfo.serviceInfo.name); |
| if (resolveInfo.serviceInfo.permission != null) { |
| Log.w(TAG, "Permission present on component " + componentName |
| + ", not adding listener record."); |
| continue; |
| } |
| enabledComponents.add(componentName); |
| } |
| // Ensure all enabled components have a record in the listener map. |
| for (ComponentName componentName : enabledComponents) { |
| if (!mRecordMap.containsKey(componentName)) { |
| if (Log.isLoggable(TAG, Log.DEBUG)) { |
| Log.d(TAG, "Adding listener record for " + componentName); |
| } |
| mRecordMap.put(componentName, new ListenerRecord(componentName)); |
| } |
| } |
| // Remove listener records that are no longer for enabled components. |
| Iterator<Map.Entry<ComponentName, ListenerRecord>> it = |
| mRecordMap.entrySet().iterator(); |
| while (it.hasNext()) { |
| Map.Entry<ComponentName, ListenerRecord> entry = it.next(); |
| if (!enabledComponents.contains(entry.getKey())) { |
| if (Log.isLoggable(TAG, Log.DEBUG)) { |
| Log.d(TAG, "Removing listener record for " + entry.getKey()); |
| } |
| ensureServiceUnbound(entry.getValue()); |
| it.remove(); |
| } |
| } |
| } |
| |
| /** |
| * Ensure we are already attempting to bind to a service, or start a new binding if not. |
| * @return Whether the service bind attempt was successful. |
| */ |
| private boolean ensureServiceBound(ListenerRecord record) { |
| if (record.bound) { |
| return true; |
| } |
| Intent intent = new Intent(ACTION_BIND_SIDE_CHANNEL).setComponent(record.componentName); |
| record.bound = mContext.bindService(intent, this, Service.BIND_AUTO_CREATE |
| | Service.BIND_WAIVE_PRIORITY); |
| if (record.bound) { |
| record.retryCount = 0; |
| } else { |
| Log.w(TAG, "Unable to bind to listener " + record.componentName); |
| mContext.unbindService(this); |
| } |
| return record.bound; |
| } |
| |
| /** |
| * Ensure we have unbound from a service. |
| */ |
| private void ensureServiceUnbound(ListenerRecord record) { |
| if (record.bound) { |
| mContext.unbindService(this); |
| record.bound = false; |
| } |
| record.service = null; |
| } |
| |
| /** |
| * Schedule a delayed retry to communicate with a listener service. |
| * After a maximum number of attempts (with exponential back-off), start |
| * dropping pending tasks for this listener. |
| */ |
| private void scheduleListenerRetry(ListenerRecord record) { |
| if (mHandler.hasMessages(MSG_RETRY_LISTENER_QUEUE, record.componentName)) { |
| return; |
| } |
| record.retryCount++; |
| if (record.retryCount > SIDE_CHANNEL_RETRY_MAX_COUNT) { |
| Log.w(TAG, "Giving up on delivering " + record.taskQueue.size() + " tasks to " |
| + record.componentName + " after " + record.retryCount + " retries"); |
| record.taskQueue.clear(); |
| return; |
| } |
| int delayMs = SIDE_CHANNEL_RETRY_BASE_INTERVAL_MS * (1 << (record.retryCount - 1)); |
| if (Log.isLoggable(TAG, Log.DEBUG)) { |
| Log.d(TAG, "Scheduling retry for " + delayMs + " ms"); |
| } |
| Message msg = mHandler.obtainMessage(MSG_RETRY_LISTENER_QUEUE, record.componentName); |
| mHandler.sendMessageDelayed(msg, delayMs); |
| } |
| |
| /** |
| * Perform a processing step for a listener. First check the bind state, then attempt |
| * to flush the task queue, and if an error is encountered, schedule a retry. |
| */ |
| private void processListenerQueue(ListenerRecord record) { |
| if (Log.isLoggable(TAG, Log.DEBUG)) { |
| Log.d(TAG, "Processing component " + record.componentName + ", " |
| + record.taskQueue.size() + " queued tasks"); |
| } |
| if (record.taskQueue.isEmpty()) { |
| return; |
| } |
| if (!ensureServiceBound(record) || record.service == null) { |
| // Ensure bind has started and that a service interface is ready to use. |
| scheduleListenerRetry(record); |
| return; |
| } |
| // Attempt to flush all items in the task queue. |
| while (true) { |
| Task task = record.taskQueue.peek(); |
| if (task == null) { |
| break; |
| } |
| try { |
| if (Log.isLoggable(TAG, Log.DEBUG)) { |
| Log.d(TAG, "Sending task " + task); |
| } |
| task.send(record.service); |
| record.taskQueue.remove(); |
| } catch (DeadObjectException e) { |
| if (Log.isLoggable(TAG, Log.DEBUG)) { |
| Log.d(TAG, "Remote service has died: " + record.componentName); |
| } |
| break; |
| } catch (RemoteException e) { |
| Log.w(TAG, "RemoteException communicating with " + record.componentName, e); |
| break; |
| } |
| } |
| if (!record.taskQueue.isEmpty()) { |
| // Some tasks were not sent, meaning an error was encountered, schedule a retry. |
| scheduleListenerRetry(record); |
| } |
| } |
| |
| /** A per-side-channel-service listener state record */ |
| private static class ListenerRecord { |
| final ComponentName componentName; |
| /** Whether the service is currently bound to. */ |
| boolean bound = false; |
| /** The service stub provided by onServiceConnected */ |
| INotificationSideChannel service; |
| /** Queue of pending tasks to send to this listener service */ |
| ArrayDeque<Task> taskQueue = new ArrayDeque<>(); |
| /** Number of retries attempted while connecting to this listener service */ |
| int retryCount = 0; |
| |
| ListenerRecord(ComponentName componentName) { |
| this.componentName = componentName; |
| } |
| } |
| } |
| |
| private static class ServiceConnectedEvent { |
| final ComponentName componentName; |
| final IBinder iBinder; |
| |
| ServiceConnectedEvent(ComponentName componentName, |
| final IBinder iBinder) { |
| this.componentName = componentName; |
| this.iBinder = iBinder; |
| } |
| } |
| |
| private interface Task { |
| void send(INotificationSideChannel service) throws RemoteException; |
| } |
| |
| private static class NotifyTask implements Task { |
| final String packageName; |
| final int id; |
| final String tag; |
| final Notification notif; |
| |
| NotifyTask(String packageName, int id, String tag, Notification notif) { |
| this.packageName = packageName; |
| this.id = id; |
| this.tag = tag; |
| this.notif = notif; |
| } |
| |
| @Override |
| public void send(INotificationSideChannel service) throws RemoteException { |
| service.notify(packageName, id, tag, notif); |
| } |
| |
| @Override |
| public String toString() { |
| StringBuilder sb = new StringBuilder("NotifyTask["); |
| sb.append("packageName:").append(packageName); |
| sb.append(", id:").append(id); |
| sb.append(", tag:").append(tag); |
| sb.append("]"); |
| return sb.toString(); |
| } |
| } |
| |
| private static class CancelTask implements Task { |
| final String packageName; |
| final int id; |
| final String tag; |
| final boolean all; |
| |
| CancelTask(String packageName) { |
| this.packageName = packageName; |
| this.id = 0; |
| this.tag = null; |
| this.all = true; |
| } |
| |
| CancelTask(String packageName, int id, String tag) { |
| this.packageName = packageName; |
| this.id = id; |
| this.tag = tag; |
| this.all = false; |
| } |
| |
| @Override |
| public void send(INotificationSideChannel service) throws RemoteException { |
| if (all) { |
| service.cancelAll(packageName); |
| } else { |
| service.cancel(packageName, id, tag); |
| } |
| } |
| |
| @Override |
| public String toString() { |
| StringBuilder sb = new StringBuilder("CancelTask["); |
| sb.append("packageName:").append(packageName); |
| sb.append(", id:").append(id); |
| sb.append(", tag:").append(tag); |
| sb.append(", all:").append(all); |
| sb.append("]"); |
| return sb.toString(); |
| } |
| } |
| } |
