1 /* 2 * Copyright (C) 2013 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package android.service.notification; 18 19 import android.annotation.IntDef; 20 import android.annotation.NonNull; 21 import android.annotation.SdkConstant; 22 import android.annotation.SystemApi; 23 import android.annotation.TestApi; 24 import android.app.ActivityManager; 25 import android.app.INotificationManager; 26 import android.app.Notification; 27 import android.app.Notification.Builder; 28 import android.app.NotificationChannel; 29 import android.app.NotificationChannelGroup; 30 import android.app.NotificationManager; 31 import android.app.Person; 32 import android.app.Service; 33 import android.companion.CompanionDeviceManager; 34 import android.content.ComponentName; 35 import android.content.Context; 36 import android.content.Intent; 37 import android.content.pm.ParceledListSlice; 38 import android.graphics.Bitmap; 39 import android.graphics.drawable.BitmapDrawable; 40 import android.graphics.drawable.Drawable; 41 import android.graphics.drawable.Icon; 42 import android.os.Build; 43 import android.os.Bundle; 44 import android.os.Handler; 45 import android.os.IBinder; 46 import android.os.Looper; 47 import android.os.Message; 48 import android.os.Parcel; 49 import android.os.Parcelable; 50 import android.os.RemoteException; 51 import android.os.ServiceManager; 52 import android.os.UserHandle; 53 import android.util.ArrayMap; 54 import android.util.ArraySet; 55 import android.util.Log; 56 import android.widget.RemoteViews; 57 58 import com.android.internal.annotations.GuardedBy; 59 import com.android.internal.annotations.VisibleForTesting; 60 import com.android.internal.os.SomeArgs; 61 62 import java.lang.annotation.Retention; 63 import java.lang.annotation.RetentionPolicy; 64 import java.util.ArrayList; 65 import java.util.Collections; 66 import java.util.List; 67 68 /** 69 * A service that receives calls from the system when new notifications are 70 * posted or removed, or their ranking changed. 71 * <p>To extend this class, you must declare the service in your manifest file with 72 * the {@link android.Manifest.permission#BIND_NOTIFICATION_LISTENER_SERVICE} permission 73 * and include an intent filter with the {@link #SERVICE_INTERFACE} action. For example:</p> 74 * <pre> 75 * <service android:name=".NotificationListener" 76 * android:label="@string/service_name" 77 * android:permission="android.permission.BIND_NOTIFICATION_LISTENER_SERVICE"> 78 * <intent-filter> 79 * <action android:name="android.service.notification.NotificationListenerService" /> 80 * </intent-filter> 81 * </service></pre> 82 * 83 * <p>The service should wait for the {@link #onListenerConnected()} event 84 * before performing any operations. The {@link #requestRebind(ComponentName)} 85 * method is the <i>only</i> one that is safe to call before {@link #onListenerConnected()} 86 * or after {@link #onListenerDisconnected()}. 87 * </p> 88 * <p> Notification listeners cannot get notification access or be bound by the system on 89 * {@linkplain ActivityManager#isLowRamDevice() low-RAM} devices. The system also ignores 90 * notification listeners running in a work profile. A 91 * {@link android.app.admin.DevicePolicyManager} might block notifications originating from a work 92 * profile.</p> 93 */ 94 public abstract class NotificationListenerService extends Service { 95 96 private final String TAG = getClass().getSimpleName(); 97 98 /** 99 * {@link #getCurrentInterruptionFilter() Interruption filter} constant - 100 * Normal interruption filter. 101 */ 102 public static final int INTERRUPTION_FILTER_ALL 103 = NotificationManager.INTERRUPTION_FILTER_ALL; 104 105 /** 106 * {@link #getCurrentInterruptionFilter() Interruption filter} constant - 107 * Priority interruption filter. 108 */ 109 public static final int INTERRUPTION_FILTER_PRIORITY 110 = NotificationManager.INTERRUPTION_FILTER_PRIORITY; 111 112 /** 113 * {@link #getCurrentInterruptionFilter() Interruption filter} constant - 114 * No interruptions filter. 115 */ 116 public static final int INTERRUPTION_FILTER_NONE 117 = NotificationManager.INTERRUPTION_FILTER_NONE; 118 119 /** 120 * {@link #getCurrentInterruptionFilter() Interruption filter} constant - 121 * Alarms only interruption filter. 122 */ 123 public static final int INTERRUPTION_FILTER_ALARMS 124 = NotificationManager.INTERRUPTION_FILTER_ALARMS; 125 126 /** {@link #getCurrentInterruptionFilter() Interruption filter} constant - returned when 127 * the value is unavailable for any reason. For example, before the notification listener 128 * is connected. 129 * 130 * {@see #onListenerConnected()} 131 */ 132 public static final int INTERRUPTION_FILTER_UNKNOWN 133 = NotificationManager.INTERRUPTION_FILTER_UNKNOWN; 134 135 /** {@link #getCurrentListenerHints() Listener hints} constant - the primary device UI 136 * should disable notification sound, vibrating and other visual or aural effects. 137 * This does not change the interruption filter, only the effects. **/ 138 public static final int HINT_HOST_DISABLE_EFFECTS = 1; 139 140 /** {@link #getCurrentListenerHints() Listener hints} constant - the primary device UI 141 * should disable notification sound, but not phone calls. 142 * This does not change the interruption filter, only the effects. **/ 143 public static final int HINT_HOST_DISABLE_NOTIFICATION_EFFECTS = 1 << 1; 144 145 /** {@link #getCurrentListenerHints() Listener hints} constant - the primary device UI 146 * should disable phone call sounds, buyt not notification sound. 147 * This does not change the interruption filter, only the effects. **/ 148 public static final int HINT_HOST_DISABLE_CALL_EFFECTS = 1 << 2; 149 150 /** 151 * Whether notification suppressed by DND should not interruption visually when the screen is 152 * off. 153 * 154 * @deprecated Use the more specific visual effects in {@link NotificationManager.Policy}. 155 */ 156 @Deprecated 157 public static final int SUPPRESSED_EFFECT_SCREEN_OFF = 158 NotificationManager.Policy.SUPPRESSED_EFFECT_SCREEN_OFF; 159 /** 160 * Whether notification suppressed by DND should not interruption visually when the screen is 161 * on. 162 * 163 * @deprecated Use the more specific visual effects in {@link NotificationManager.Policy}. 164 */ 165 @Deprecated 166 public static final int SUPPRESSED_EFFECT_SCREEN_ON = 167 NotificationManager.Policy.SUPPRESSED_EFFECT_SCREEN_ON; 168 169 170 // Notification cancellation reasons 171 172 /** Notification was canceled by the status bar reporting a notification click. */ 173 public static final int REASON_CLICK = 1; 174 /** Notification was canceled by the status bar reporting a user dismissal. */ 175 public static final int REASON_CANCEL = 2; 176 /** Notification was canceled by the status bar reporting a user dismiss all. */ 177 public static final int REASON_CANCEL_ALL = 3; 178 /** Notification was canceled by the status bar reporting an inflation error. */ 179 public static final int REASON_ERROR = 4; 180 /** Notification was canceled by the package manager modifying the package. */ 181 public static final int REASON_PACKAGE_CHANGED = 5; 182 /** Notification was canceled by the owning user context being stopped. */ 183 public static final int REASON_USER_STOPPED = 6; 184 /** Notification was canceled by the user banning the package. */ 185 public static final int REASON_PACKAGE_BANNED = 7; 186 /** Notification was canceled by the app canceling this specific notification. */ 187 public static final int REASON_APP_CANCEL = 8; 188 /** Notification was canceled by the app cancelling all its notifications. */ 189 public static final int REASON_APP_CANCEL_ALL = 9; 190 /** Notification was canceled by a listener reporting a user dismissal. */ 191 public static final int REASON_LISTENER_CANCEL = 10; 192 /** Notification was canceled by a listener reporting a user dismiss all. */ 193 public static final int REASON_LISTENER_CANCEL_ALL = 11; 194 /** Notification was canceled because it was a member of a canceled group. */ 195 public static final int REASON_GROUP_SUMMARY_CANCELED = 12; 196 /** Notification was canceled because it was an invisible member of a group. */ 197 public static final int REASON_GROUP_OPTIMIZATION = 13; 198 /** Notification was canceled by the device administrator suspending the package. */ 199 public static final int REASON_PACKAGE_SUSPENDED = 14; 200 /** Notification was canceled by the owning managed profile being turned off. */ 201 public static final int REASON_PROFILE_TURNED_OFF = 15; 202 /** Autobundled summary notification was canceled because its group was unbundled */ 203 public static final int REASON_UNAUTOBUNDLED = 16; 204 /** Notification was canceled by the user banning the channel. */ 205 public static final int REASON_CHANNEL_BANNED = 17; 206 /** Notification was snoozed. */ 207 public static final int REASON_SNOOZED = 18; 208 /** Notification was canceled due to timeout */ 209 public static final int REASON_TIMEOUT = 19; 210 211 /** 212 * The full trim of the StatusBarNotification including all its features. 213 * 214 * @hide 215 * @removed 216 */ 217 @SystemApi 218 public static final int TRIM_FULL = 0; 219 220 /** 221 * A light trim of the StatusBarNotification excluding the following features: 222 * 223 * <ol> 224 * <li>{@link Notification#tickerView tickerView}</li> 225 * <li>{@link Notification#contentView contentView}</li> 226 * <li>{@link Notification#largeIcon largeIcon}</li> 227 * <li>{@link Notification#bigContentView bigContentView}</li> 228 * <li>{@link Notification#headsUpContentView headsUpContentView}</li> 229 * <li>{@link Notification#EXTRA_LARGE_ICON extras[EXTRA_LARGE_ICON]}</li> 230 * <li>{@link Notification#EXTRA_LARGE_ICON_BIG extras[EXTRA_LARGE_ICON_BIG]}</li> 231 * <li>{@link Notification#EXTRA_PICTURE extras[EXTRA_PICTURE]}</li> 232 * <li>{@link Notification#EXTRA_BIG_TEXT extras[EXTRA_BIG_TEXT]}</li> 233 * </ol> 234 * 235 * @hide 236 * @removed 237 */ 238 @SystemApi 239 public static final int TRIM_LIGHT = 1; 240 241 242 /** @hide */ 243 @IntDef(prefix = { "NOTIFICATION_CHANNEL_OR_GROUP_" }, value = { 244 NOTIFICATION_CHANNEL_OR_GROUP_ADDED, 245 NOTIFICATION_CHANNEL_OR_GROUP_UPDATED, 246 NOTIFICATION_CHANNEL_OR_GROUP_DELETED 247 }) 248 @Retention(RetentionPolicy.SOURCE) 249 public @interface ChannelOrGroupModificationTypes {} 250 251 /** 252 * Channel or group modification reason provided to 253 * {@link #onNotificationChannelModified(String, UserHandle,NotificationChannel, int)} or 254 * {@link #onNotificationChannelGroupModified(String, UserHandle, NotificationChannelGroup, 255 * int)}- the provided object was created. 256 */ 257 public static final int NOTIFICATION_CHANNEL_OR_GROUP_ADDED = 1; 258 259 /** 260 * Channel or group modification reason provided to 261 * {@link #onNotificationChannelModified(String, UserHandle, NotificationChannel, int)} or 262 * {@link #onNotificationChannelGroupModified(String, UserHandle,NotificationChannelGroup, int)} 263 * - the provided object was updated. 264 */ 265 public static final int NOTIFICATION_CHANNEL_OR_GROUP_UPDATED = 2; 266 267 /** 268 * Channel or group modification reason provided to 269 * {@link #onNotificationChannelModified(String, UserHandle, NotificationChannel, int)} or 270 * {@link #onNotificationChannelGroupModified(String, UserHandle, NotificationChannelGroup, 271 * int)}- the provided object was deleted. 272 */ 273 public static final int NOTIFICATION_CHANNEL_OR_GROUP_DELETED = 3; 274 275 private final Object mLock = new Object(); 276 277 private Handler mHandler; 278 279 /** @hide */ 280 protected NotificationListenerWrapper mWrapper = null; 281 private boolean isConnected = false; 282 283 @GuardedBy("mLock") 284 private RankingMap mRankingMap; 285 286 /** 287 * @hide 288 */ 289 protected INotificationManager mNoMan; 290 291 /** 292 * Only valid after a successful call to (@link registerAsService}. 293 * @hide 294 */ 295 protected int mCurrentUser; 296 297 /** 298 * This context is required for system services since NotificationListenerService isn't 299 * started as a real Service and hence no context is available.. 300 * @hide 301 */ 302 protected Context mSystemContext; 303 304 /** 305 * The {@link Intent} that must be declared as handled by the service. 306 */ 307 @SdkConstant(SdkConstant.SdkConstantType.SERVICE_ACTION) 308 public static final String SERVICE_INTERFACE 309 = "android.service.notification.NotificationListenerService"; 310 311 @Override attachBaseContext(Context base)312 protected void attachBaseContext(Context base) { 313 super.attachBaseContext(base); 314 mHandler = new MyHandler(getMainLooper()); 315 } 316 317 /** 318 * Implement this method to learn about new notifications as they are posted by apps. 319 * 320 * @param sbn A data structure encapsulating the original {@link android.app.Notification} 321 * object as well as its identifying information (tag and id) and source 322 * (package name). 323 */ onNotificationPosted(StatusBarNotification sbn)324 public void onNotificationPosted(StatusBarNotification sbn) { 325 // optional 326 } 327 328 /** 329 * Implement this method to learn about new notifications as they are posted by apps. 330 * 331 * @param sbn A data structure encapsulating the original {@link android.app.Notification} 332 * object as well as its identifying information (tag and id) and source 333 * (package name). 334 * @param rankingMap The current ranking map that can be used to retrieve ranking information 335 * for active notifications, including the newly posted one. 336 */ onNotificationPosted(StatusBarNotification sbn, RankingMap rankingMap)337 public void onNotificationPosted(StatusBarNotification sbn, RankingMap rankingMap) { 338 onNotificationPosted(sbn); 339 } 340 341 /** 342 * Implement this method to learn when notifications are removed. 343 * <p> 344 * This might occur because the user has dismissed the notification using system UI (or another 345 * notification listener) or because the app has withdrawn the notification. 346 * <p> 347 * NOTE: The {@link StatusBarNotification} object you receive will be "light"; that is, the 348 * result from {@link StatusBarNotification#getNotification} may be missing some heavyweight 349 * fields such as {@link android.app.Notification#contentView} and 350 * {@link android.app.Notification#largeIcon}. However, all other fields on 351 * {@link StatusBarNotification}, sufficient to match this call with a prior call to 352 * {@link #onNotificationPosted(StatusBarNotification)}, will be intact. 353 * 354 * @param sbn A data structure encapsulating at least the original information (tag and id) 355 * and source (package name) used to post the {@link android.app.Notification} that 356 * was just removed. 357 */ onNotificationRemoved(StatusBarNotification sbn)358 public void onNotificationRemoved(StatusBarNotification sbn) { 359 // optional 360 } 361 362 /** 363 * Implement this method to learn when notifications are removed. 364 * <p> 365 * This might occur because the user has dismissed the notification using system UI (or another 366 * notification listener) or because the app has withdrawn the notification. 367 * <p> 368 * NOTE: The {@link StatusBarNotification} object you receive will be "light"; that is, the 369 * result from {@link StatusBarNotification#getNotification} may be missing some heavyweight 370 * fields such as {@link android.app.Notification#contentView} and 371 * {@link android.app.Notification#largeIcon}. However, all other fields on 372 * {@link StatusBarNotification}, sufficient to match this call with a prior call to 373 * {@link #onNotificationPosted(StatusBarNotification)}, will be intact. 374 * 375 * @param sbn A data structure encapsulating at least the original information (tag and id) 376 * and source (package name) used to post the {@link android.app.Notification} that 377 * was just removed. 378 * @param rankingMap The current ranking map that can be used to retrieve ranking information 379 * for active notifications. 380 * 381 */ onNotificationRemoved(StatusBarNotification sbn, RankingMap rankingMap)382 public void onNotificationRemoved(StatusBarNotification sbn, RankingMap rankingMap) { 383 onNotificationRemoved(sbn); 384 } 385 386 387 /** 388 * Implement this method to learn when notifications are removed and why. 389 * <p> 390 * This might occur because the user has dismissed the notification using system UI (or another 391 * notification listener) or because the app has withdrawn the notification. 392 * <p> 393 * NOTE: The {@link StatusBarNotification} object you receive will be "light"; that is, the 394 * result from {@link StatusBarNotification#getNotification} may be missing some heavyweight 395 * fields such as {@link android.app.Notification#contentView} and 396 * {@link android.app.Notification#largeIcon}. However, all other fields on 397 * {@link StatusBarNotification}, sufficient to match this call with a prior call to 398 * {@link #onNotificationPosted(StatusBarNotification)}, will be intact. 399 * 400 ** @param sbn A data structure encapsulating at least the original information (tag and id) 401 * and source (package name) used to post the {@link android.app.Notification} that 402 * was just removed. 403 * @param rankingMap The current ranking map that can be used to retrieve ranking information 404 * for active notifications. 405 * @param reason see {@link #REASON_LISTENER_CANCEL}, etc. 406 */ onNotificationRemoved(StatusBarNotification sbn, RankingMap rankingMap, int reason)407 public void onNotificationRemoved(StatusBarNotification sbn, RankingMap rankingMap, 408 int reason) { 409 onNotificationRemoved(sbn, rankingMap); 410 } 411 412 /** 413 * NotificationStats are not populated for notification listeners, so fall back to 414 * {@link #onNotificationRemoved(StatusBarNotification, RankingMap, int)}. 415 * 416 * @hide 417 */ 418 @TestApi onNotificationRemoved(StatusBarNotification sbn, RankingMap rankingMap, NotificationStats stats, int reason)419 public void onNotificationRemoved(StatusBarNotification sbn, RankingMap rankingMap, 420 NotificationStats stats, int reason) { 421 onNotificationRemoved(sbn, rankingMap, reason); 422 } 423 424 /** 425 * Implement this method to learn about when the listener is enabled and connected to 426 * the notification manager. You are safe to call {@link #getActiveNotifications()} 427 * at this time. 428 */ onListenerConnected()429 public void onListenerConnected() { 430 // optional 431 } 432 433 /** 434 * Implement this method to learn about when the listener is disconnected from the 435 * notification manager.You will not receive any events after this call, and may only 436 * call {@link #requestRebind(ComponentName)} at this time. 437 */ onListenerDisconnected()438 public void onListenerDisconnected() { 439 // optional 440 } 441 442 /** 443 * Implement this method to be notified when the notification ranking changes. 444 * 445 * @param rankingMap The current ranking map that can be used to retrieve ranking information 446 * for active notifications. 447 */ onNotificationRankingUpdate(RankingMap rankingMap)448 public void onNotificationRankingUpdate(RankingMap rankingMap) { 449 // optional 450 } 451 452 /** 453 * Implement this method to be notified when the 454 * {@link #getCurrentListenerHints() Listener hints} change. 455 * 456 * @param hints The current {@link #getCurrentListenerHints() listener hints}. 457 */ onListenerHintsChanged(int hints)458 public void onListenerHintsChanged(int hints) { 459 // optional 460 } 461 462 /** 463 * Implement this method to learn about notification channel modifications. 464 * 465 * <p>The caller must have {@link CompanionDeviceManager#getAssociations() an associated 466 * device} in order to receive this callback. 467 * 468 * @param pkg The package the channel belongs to. 469 * @param user The user on which the change was made. 470 * @param channel The channel that has changed. 471 * @param modificationType One of {@link #NOTIFICATION_CHANNEL_OR_GROUP_ADDED}, 472 * {@link #NOTIFICATION_CHANNEL_OR_GROUP_UPDATED}, 473 * {@link #NOTIFICATION_CHANNEL_OR_GROUP_DELETED}. 474 */ onNotificationChannelModified(String pkg, UserHandle user, NotificationChannel channel, @ChannelOrGroupModificationTypes int modificationType)475 public void onNotificationChannelModified(String pkg, UserHandle user, 476 NotificationChannel channel, @ChannelOrGroupModificationTypes int modificationType) { 477 // optional 478 } 479 480 /** 481 * Implement this method to learn about notification channel group modifications. 482 * 483 * <p>The caller must have {@link CompanionDeviceManager#getAssociations() an associated 484 * device} in order to receive this callback. 485 * 486 * @param pkg The package the group belongs to. 487 * @param user The user on which the change was made. 488 * @param group The group that has changed. 489 * @param modificationType One of {@link #NOTIFICATION_CHANNEL_OR_GROUP_ADDED}, 490 * {@link #NOTIFICATION_CHANNEL_OR_GROUP_UPDATED}, 491 * {@link #NOTIFICATION_CHANNEL_OR_GROUP_DELETED}. 492 */ onNotificationChannelGroupModified(String pkg, UserHandle user, NotificationChannelGroup group, @ChannelOrGroupModificationTypes int modificationType)493 public void onNotificationChannelGroupModified(String pkg, UserHandle user, 494 NotificationChannelGroup group, @ChannelOrGroupModificationTypes int modificationType) { 495 // optional 496 } 497 498 /** 499 * Implement this method to be notified when the 500 * {@link #getCurrentInterruptionFilter() interruption filter} changed. 501 * 502 * @param interruptionFilter The current 503 * {@link #getCurrentInterruptionFilter() interruption filter}. 504 */ onInterruptionFilterChanged(int interruptionFilter)505 public void onInterruptionFilterChanged(int interruptionFilter) { 506 // optional 507 } 508 509 /** @hide */ getNotificationInterface()510 protected final INotificationManager getNotificationInterface() { 511 if (mNoMan == null) { 512 mNoMan = INotificationManager.Stub.asInterface( 513 ServiceManager.getService(Context.NOTIFICATION_SERVICE)); 514 } 515 return mNoMan; 516 } 517 518 /** 519 * Inform the notification manager about dismissal of a single notification. 520 * <p> 521 * Use this if your listener has a user interface that allows the user to dismiss individual 522 * notifications, similar to the behavior of Android's status bar and notification panel. 523 * It should be called after the user dismisses a single notification using your UI; 524 * upon being informed, the notification manager will actually remove the notification 525 * and you will get an {@link #onNotificationRemoved(StatusBarNotification)} callback. 526 * <p> 527 * <b>Note:</b> If your listener allows the user to fire a notification's 528 * {@link android.app.Notification#contentIntent} by tapping/clicking/etc., you should call 529 * this method at that time <i>if</i> the Notification in question has the 530 * {@link android.app.Notification#FLAG_AUTO_CANCEL} flag set. 531 * 532 * <p>The service should wait for the {@link #onListenerConnected()} event 533 * before performing this operation. 534 * 535 * @param pkg Package of the notifying app. 536 * @param tag Tag of the notification as specified by the notifying app in 537 * {@link android.app.NotificationManager#notify(String, int, android.app.Notification)}. 538 * @param id ID of the notification as specified by the notifying app in 539 * {@link android.app.NotificationManager#notify(String, int, android.app.Notification)}. 540 * <p> 541 * @deprecated Use {@link #cancelNotification(String key)} 542 * instead. Beginning with {@link android.os.Build.VERSION_CODES#LOLLIPOP} this method will no longer 543 * cancel the notification. It will continue to cancel the notification for applications 544 * whose {@code targetSdkVersion} is earlier than {@link android.os.Build.VERSION_CODES#LOLLIPOP}. 545 */ 546 @Deprecated cancelNotification(String pkg, String tag, int id)547 public final void cancelNotification(String pkg, String tag, int id) { 548 if (!isBound()) return; 549 try { 550 getNotificationInterface().cancelNotificationFromListener( 551 mWrapper, pkg, tag, id); 552 } catch (android.os.RemoteException ex) { 553 Log.v(TAG, "Unable to contact notification manager", ex); 554 } 555 } 556 557 /** 558 * Inform the notification manager about dismissal of a single notification. 559 * <p> 560 * Use this if your listener has a user interface that allows the user to dismiss individual 561 * notifications, similar to the behavior of Android's status bar and notification panel. 562 * It should be called after the user dismisses a single notification using your UI; 563 * upon being informed, the notification manager will actually remove the notification 564 * and you will get an {@link #onNotificationRemoved(StatusBarNotification)} callback. 565 * <p> 566 * <b>Note:</b> If your listener allows the user to fire a notification's 567 * {@link android.app.Notification#contentIntent} by tapping/clicking/etc., you should call 568 * this method at that time <i>if</i> the Notification in question has the 569 * {@link android.app.Notification#FLAG_AUTO_CANCEL} flag set. 570 * <p> 571 * 572 * <p>The service should wait for the {@link #onListenerConnected()} event 573 * before performing this operation. 574 * 575 * @param key Notification to dismiss from {@link StatusBarNotification#getKey()}. 576 */ cancelNotification(String key)577 public final void cancelNotification(String key) { 578 if (!isBound()) return; 579 try { 580 getNotificationInterface().cancelNotificationsFromListener(mWrapper, 581 new String[] { key }); 582 } catch (android.os.RemoteException ex) { 583 Log.v(TAG, "Unable to contact notification manager", ex); 584 } 585 } 586 587 /** 588 * Inform the notification manager about dismissal of all notifications. 589 * <p> 590 * Use this if your listener has a user interface that allows the user to dismiss all 591 * notifications, similar to the behavior of Android's status bar and notification panel. 592 * It should be called after the user invokes the "dismiss all" function of your UI; 593 * upon being informed, the notification manager will actually remove all active notifications 594 * and you will get multiple {@link #onNotificationRemoved(StatusBarNotification)} callbacks. 595 * 596 * <p>The service should wait for the {@link #onListenerConnected()} event 597 * before performing this operation. 598 * 599 * {@see #cancelNotification(String, String, int)} 600 */ cancelAllNotifications()601 public final void cancelAllNotifications() { 602 cancelNotifications(null /*all*/); 603 } 604 605 /** 606 * Inform the notification manager about dismissal of specific notifications. 607 * <p> 608 * Use this if your listener has a user interface that allows the user to dismiss 609 * multiple notifications at once. 610 * 611 * <p>The service should wait for the {@link #onListenerConnected()} event 612 * before performing this operation. 613 * 614 * @param keys Notifications to dismiss, or {@code null} to dismiss all. 615 * 616 * {@see #cancelNotification(String, String, int)} 617 */ cancelNotifications(String[] keys)618 public final void cancelNotifications(String[] keys) { 619 if (!isBound()) return; 620 try { 621 getNotificationInterface().cancelNotificationsFromListener(mWrapper, keys); 622 } catch (android.os.RemoteException ex) { 623 Log.v(TAG, "Unable to contact notification manager", ex); 624 } 625 } 626 627 /** 628 * Inform the notification manager about snoozing a specific notification. 629 * <p> 630 * Use this if your listener has a user interface that allows the user to snooze a notification 631 * until a given {@link SnoozeCriterion}. It should be called after the user snoozes a single 632 * notification using your UI; upon being informed, the notification manager will actually 633 * remove the notification and you will get an 634 * {@link #onNotificationRemoved(StatusBarNotification)} callback. When the snoozing period 635 * expires, you will get a {@link #onNotificationPosted(StatusBarNotification, RankingMap)} 636 * callback for the notification. 637 * @param key The key of the notification to snooze 638 * @param snoozeCriterionId The{@link SnoozeCriterion#getId()} of a context to snooze the 639 * notification until. 640 * @hide 641 * @removed 642 */ 643 @SystemApi snoozeNotification(String key, String snoozeCriterionId)644 public final void snoozeNotification(String key, String snoozeCriterionId) { 645 if (!isBound()) return; 646 try { 647 getNotificationInterface().snoozeNotificationUntilContextFromListener( 648 mWrapper, key, snoozeCriterionId); 649 } catch (android.os.RemoteException ex) { 650 Log.v(TAG, "Unable to contact notification manager", ex); 651 } 652 } 653 654 /** 655 * Inform the notification manager about snoozing a specific notification. 656 * <p> 657 * Use this if your listener has a user interface that allows the user to snooze a notification 658 * for a time. It should be called after the user snoozes a single notification using 659 * your UI; upon being informed, the notification manager will actually remove the notification 660 * and you will get an {@link #onNotificationRemoved(StatusBarNotification)} callback. When the 661 * snoozing period expires, you will get a 662 * {@link #onNotificationPosted(StatusBarNotification, RankingMap)} callback for the 663 * notification. 664 * @param key The key of the notification to snooze 665 * @param durationMs A duration to snooze the notification for, in milliseconds. 666 */ snoozeNotification(String key, long durationMs)667 public final void snoozeNotification(String key, long durationMs) { 668 if (!isBound()) return; 669 try { 670 getNotificationInterface().snoozeNotificationUntilFromListener( 671 mWrapper, key, durationMs); 672 } catch (android.os.RemoteException ex) { 673 Log.v(TAG, "Unable to contact notification manager", ex); 674 } 675 } 676 677 678 /** 679 * Inform the notification manager that these notifications have been viewed by the 680 * user. This should only be called when there is sufficient confidence that the user is 681 * looking at the notifications, such as when the notifications appear on the screen due to 682 * an explicit user interaction. 683 * 684 * <p>The service should wait for the {@link #onListenerConnected()} event 685 * before performing this operation. 686 * 687 * @param keys Notifications to mark as seen. 688 */ setNotificationsShown(String[] keys)689 public final void setNotificationsShown(String[] keys) { 690 if (!isBound()) return; 691 try { 692 getNotificationInterface().setNotificationsShownFromListener(mWrapper, keys); 693 } catch (android.os.RemoteException ex) { 694 Log.v(TAG, "Unable to contact notification manager", ex); 695 } 696 } 697 698 699 /** 700 * Updates a notification channel for a given package for a given user. This should only be used 701 * to reflect changes a user has made to the channel via the listener's user interface. 702 * 703 * <p>This method will throw a security exception if you don't have access to notifications 704 * for the given user.</p> 705 * <p>The caller must have {@link CompanionDeviceManager#getAssociations() an associated 706 * device} in order to use this method. 707 * 708 * @param pkg The package the channel belongs to. 709 * @param user The user the channel belongs to. 710 * @param channel the channel to update. 711 */ updateNotificationChannel(@onNull String pkg, @NonNull UserHandle user, @NonNull NotificationChannel channel)712 public final void updateNotificationChannel(@NonNull String pkg, @NonNull UserHandle user, 713 @NonNull NotificationChannel channel) { 714 if (!isBound()) return; 715 try { 716 getNotificationInterface().updateNotificationChannelFromPrivilegedListener( 717 mWrapper, pkg, user, channel); 718 } catch (RemoteException e) { 719 Log.v(TAG, "Unable to contact notification manager", e); 720 throw e.rethrowFromSystemServer(); 721 } 722 } 723 724 /** 725 * Returns all notification channels belonging to the given package for a given user. 726 * 727 * <p>This method will throw a security exception if you don't have access to notifications 728 * for the given user.</p> 729 * <p>The caller must have {@link CompanionDeviceManager#getAssociations() an associated 730 * device} in order to use this method. 731 * 732 * @param pkg The package to retrieve channels for. 733 */ getNotificationChannels(@onNull String pkg, @NonNull UserHandle user)734 public final List<NotificationChannel> getNotificationChannels(@NonNull String pkg, 735 @NonNull UserHandle user) { 736 if (!isBound()) return null; 737 try { 738 739 return getNotificationInterface().getNotificationChannelsFromPrivilegedListener( 740 mWrapper, pkg, user).getList(); 741 } catch (RemoteException e) { 742 Log.v(TAG, "Unable to contact notification manager", e); 743 throw e.rethrowFromSystemServer(); 744 } 745 } 746 747 /** 748 * Returns all notification channel groups belonging to the given package for a given user. 749 * 750 * <p>This method will throw a security exception if you don't have access to notifications 751 * for the given user.</p> 752 * <p>The caller must have {@link CompanionDeviceManager#getAssociations() an associated 753 * device} in order to use this method. 754 * 755 * @param pkg The package to retrieve channel groups for. 756 */ getNotificationChannelGroups(@onNull String pkg, @NonNull UserHandle user)757 public final List<NotificationChannelGroup> getNotificationChannelGroups(@NonNull String pkg, 758 @NonNull UserHandle user) { 759 if (!isBound()) return null; 760 try { 761 762 return getNotificationInterface().getNotificationChannelGroupsFromPrivilegedListener( 763 mWrapper, pkg, user).getList(); 764 } catch (RemoteException e) { 765 Log.v(TAG, "Unable to contact notification manager", e); 766 throw e.rethrowFromSystemServer(); 767 } 768 } 769 770 /** 771 * Sets the notification trim that will be received via {@link #onNotificationPosted}. 772 * 773 * <p> 774 * Setting a trim other than {@link #TRIM_FULL} enables listeners that don't need access to the 775 * full notification features right away to reduce their memory footprint. Full notifications 776 * can be requested on-demand via {@link #getActiveNotifications(int)}. 777 * 778 * <p> 779 * Set to {@link #TRIM_FULL} initially. 780 * 781 * <p>The service should wait for the {@link #onListenerConnected()} event 782 * before performing this operation. 783 * 784 * @hide 785 * @removed 786 * 787 * @param trim trim of the notifications to be passed via {@link #onNotificationPosted}. 788 * See <code>TRIM_*</code> constants. 789 */ 790 @SystemApi setOnNotificationPostedTrim(int trim)791 public final void setOnNotificationPostedTrim(int trim) { 792 if (!isBound()) return; 793 try { 794 getNotificationInterface().setOnNotificationPostedTrimFromListener(mWrapper, trim); 795 } catch (RemoteException ex) { 796 Log.v(TAG, "Unable to contact notification manager", ex); 797 } 798 } 799 800 /** 801 * Request the list of outstanding notifications (that is, those that are visible to the 802 * current user). Useful when you don't know what's already been posted. 803 * 804 * <p>The service should wait for the {@link #onListenerConnected()} event 805 * before performing this operation. 806 * 807 * @return An array of active notifications, sorted in natural order. 808 */ getActiveNotifications()809 public StatusBarNotification[] getActiveNotifications() { 810 StatusBarNotification[] activeNotifications = getActiveNotifications(null, TRIM_FULL); 811 return activeNotifications != null ? activeNotifications : new StatusBarNotification[0]; 812 } 813 814 /** 815 * Like {@link #getActiveNotifications()}, but returns the list of currently snoozed 816 * notifications, for all users this listener has access to. 817 * 818 * <p>The service should wait for the {@link #onListenerConnected()} event 819 * before performing this operation. 820 * 821 * @return An array of snoozed notifications, sorted in natural order. 822 */ getSnoozedNotifications()823 public final StatusBarNotification[] getSnoozedNotifications() { 824 try { 825 ParceledListSlice<StatusBarNotification> parceledList = getNotificationInterface() 826 .getSnoozedNotificationsFromListener(mWrapper, TRIM_FULL); 827 return cleanUpNotificationList(parceledList); 828 } catch (android.os.RemoteException ex) { 829 Log.v(TAG, "Unable to contact notification manager", ex); 830 } 831 return null; 832 } 833 834 /** 835 * Request the list of outstanding notifications (that is, those that are visible to the 836 * current user). Useful when you don't know what's already been posted. 837 * 838 * @hide 839 * @removed 840 * 841 * @param trim trim of the notifications to be returned. See <code>TRIM_*</code> constants. 842 * @return An array of active notifications, sorted in natural order. 843 */ 844 @SystemApi getActiveNotifications(int trim)845 public StatusBarNotification[] getActiveNotifications(int trim) { 846 StatusBarNotification[] activeNotifications = getActiveNotifications(null, trim); 847 return activeNotifications != null ? activeNotifications : new StatusBarNotification[0]; 848 } 849 850 /** 851 * Request one or more notifications by key. Useful if you have been keeping track of 852 * notifications but didn't want to retain the bits, and now need to go back and extract 853 * more data out of those notifications. 854 * 855 * <p>The service should wait for the {@link #onListenerConnected()} event 856 * before performing this operation. 857 * 858 * @param keys the keys of the notifications to request 859 * @return An array of notifications corresponding to the requested keys, in the 860 * same order as the key list. 861 */ getActiveNotifications(String[] keys)862 public StatusBarNotification[] getActiveNotifications(String[] keys) { 863 StatusBarNotification[] activeNotifications = getActiveNotifications(keys, TRIM_FULL); 864 return activeNotifications != null ? activeNotifications : new StatusBarNotification[0]; 865 } 866 867 /** 868 * Request one or more notifications by key. Useful if you have been keeping track of 869 * notifications but didn't want to retain the bits, and now need to go back and extract 870 * more data out of those notifications. 871 * 872 * @hide 873 * @removed 874 * 875 * @param keys the keys of the notifications to request 876 * @param trim trim of the notifications to be returned. See <code>TRIM_*</code> constants. 877 * @return An array of notifications corresponding to the requested keys, in the 878 * same order as the key list. 879 */ 880 @SystemApi getActiveNotifications(String[] keys, int trim)881 public StatusBarNotification[] getActiveNotifications(String[] keys, int trim) { 882 if (!isBound()) 883 return null; 884 try { 885 ParceledListSlice<StatusBarNotification> parceledList = getNotificationInterface() 886 .getActiveNotificationsFromListener(mWrapper, keys, trim); 887 return cleanUpNotificationList(parceledList); 888 } catch (android.os.RemoteException ex) { 889 Log.v(TAG, "Unable to contact notification manager", ex); 890 } 891 return null; 892 } 893 cleanUpNotificationList( ParceledListSlice<StatusBarNotification> parceledList)894 private StatusBarNotification[] cleanUpNotificationList( 895 ParceledListSlice<StatusBarNotification> parceledList) { 896 if (parceledList == null || parceledList.getList() == null) { 897 return new StatusBarNotification[0]; 898 } 899 List<StatusBarNotification> list = parceledList.getList(); 900 ArrayList<StatusBarNotification> corruptNotifications = null; 901 int N = list.size(); 902 for (int i = 0; i < N; i++) { 903 StatusBarNotification sbn = list.get(i); 904 Notification notification = sbn.getNotification(); 905 try { 906 // convert icon metadata to legacy format for older clients 907 createLegacyIconExtras(notification); 908 // populate remote views for older clients. 909 maybePopulateRemoteViews(notification); 910 // populate people for older clients. 911 maybePopulatePeople(notification); 912 } catch (IllegalArgumentException e) { 913 if (corruptNotifications == null) { 914 corruptNotifications = new ArrayList<>(N); 915 } 916 corruptNotifications.add(sbn); 917 Log.w(TAG, "get(Active/Snoozed)Notifications: can't rebuild notification from " + 918 sbn.getPackageName()); 919 } 920 } 921 if (corruptNotifications != null) { 922 list.removeAll(corruptNotifications); 923 } 924 return list.toArray(new StatusBarNotification[list.size()]); 925 } 926 927 /** 928 * Gets the set of hints representing current state. 929 * 930 * <p> 931 * The current state may differ from the requested state if the hint represents state 932 * shared across all listeners or a feature the notification host does not support or refuses 933 * to grant. 934 * 935 * <p>The service should wait for the {@link #onListenerConnected()} event 936 * before performing this operation. 937 * 938 * @return Zero or more of the HINT_ constants. 939 */ getCurrentListenerHints()940 public final int getCurrentListenerHints() { 941 if (!isBound()) return 0; 942 try { 943 return getNotificationInterface().getHintsFromListener(mWrapper); 944 } catch (android.os.RemoteException ex) { 945 Log.v(TAG, "Unable to contact notification manager", ex); 946 return 0; 947 } 948 } 949 950 /** 951 * Gets the current notification interruption filter active on the host. 952 * 953 * <p> 954 * The interruption filter defines which notifications are allowed to interrupt the user 955 * (e.g. via sound & vibration) and is applied globally. Listeners can find out whether 956 * a specific notification matched the interruption filter via 957 * {@link Ranking#matchesInterruptionFilter()}. 958 * <p> 959 * The current filter may differ from the previously requested filter if the notification host 960 * does not support or refuses to apply the requested filter, or if another component changed 961 * the filter in the meantime. 962 * <p> 963 * Listen for updates using {@link #onInterruptionFilterChanged(int)}. 964 * 965 * <p>The service should wait for the {@link #onListenerConnected()} event 966 * before performing this operation. 967 * 968 * @return One of the INTERRUPTION_FILTER_ constants, or INTERRUPTION_FILTER_UNKNOWN when 969 * unavailable. 970 */ getCurrentInterruptionFilter()971 public final int getCurrentInterruptionFilter() { 972 if (!isBound()) return INTERRUPTION_FILTER_UNKNOWN; 973 try { 974 return getNotificationInterface().getInterruptionFilterFromListener(mWrapper); 975 } catch (android.os.RemoteException ex) { 976 Log.v(TAG, "Unable to contact notification manager", ex); 977 return INTERRUPTION_FILTER_UNKNOWN; 978 } 979 } 980 981 /** 982 * Sets the desired {@link #getCurrentListenerHints() listener hints}. 983 * 984 * <p> 985 * This is merely a request, the host may or may not choose to take action depending 986 * on other listener requests or other global state. 987 * <p> 988 * Listen for updates using {@link #onListenerHintsChanged(int)}. 989 * 990 * <p>The service should wait for the {@link #onListenerConnected()} event 991 * before performing this operation. 992 * 993 * @param hints One or more of the HINT_ constants. 994 */ requestListenerHints(int hints)995 public final void requestListenerHints(int hints) { 996 if (!isBound()) return; 997 try { 998 getNotificationInterface().requestHintsFromListener(mWrapper, hints); 999 } catch (android.os.RemoteException ex) { 1000 Log.v(TAG, "Unable to contact notification manager", ex); 1001 } 1002 } 1003 1004 /** 1005 * Sets the desired {@link #getCurrentInterruptionFilter() interruption filter}. 1006 * 1007 * <p> 1008 * This is merely a request, the host may or may not choose to apply the requested 1009 * interruption filter depending on other listener requests or other global state. 1010 * <p> 1011 * Listen for updates using {@link #onInterruptionFilterChanged(int)}. 1012 * 1013 * <p>The service should wait for the {@link #onListenerConnected()} event 1014 * before performing this operation. 1015 * 1016 * @param interruptionFilter One of the INTERRUPTION_FILTER_ constants. 1017 */ requestInterruptionFilter(int interruptionFilter)1018 public final void requestInterruptionFilter(int interruptionFilter) { 1019 if (!isBound()) return; 1020 try { 1021 getNotificationInterface() 1022 .requestInterruptionFilterFromListener(mWrapper, interruptionFilter); 1023 } catch (android.os.RemoteException ex) { 1024 Log.v(TAG, "Unable to contact notification manager", ex); 1025 } 1026 } 1027 1028 /** 1029 * Returns current ranking information. 1030 * 1031 * <p> 1032 * The returned object represents the current ranking snapshot and only 1033 * applies for currently active notifications. 1034 * <p> 1035 * Generally you should use the RankingMap that is passed with events such 1036 * as {@link #onNotificationPosted(StatusBarNotification, RankingMap)}, 1037 * {@link #onNotificationRemoved(StatusBarNotification, RankingMap)}, and 1038 * so on. This method should only be used when needing access outside of 1039 * such events, for example to retrieve the RankingMap right after 1040 * initialization. 1041 * 1042 * <p>The service should wait for the {@link #onListenerConnected()} event 1043 * before performing this operation. 1044 * 1045 * @return A {@link RankingMap} object providing access to ranking information 1046 */ getCurrentRanking()1047 public RankingMap getCurrentRanking() { 1048 synchronized (mLock) { 1049 return mRankingMap; 1050 } 1051 } 1052 1053 /** 1054 * This is not the lifecycle event you are looking for. 1055 * 1056 * <p>The service should wait for the {@link #onListenerConnected()} event 1057 * before performing any operations. 1058 */ 1059 @Override onBind(Intent intent)1060 public IBinder onBind(Intent intent) { 1061 if (mWrapper == null) { 1062 mWrapper = new NotificationListenerWrapper(); 1063 } 1064 return mWrapper; 1065 } 1066 1067 /** @hide */ isBound()1068 protected boolean isBound() { 1069 if (mWrapper == null) { 1070 Log.w(TAG, "Notification listener service not yet bound."); 1071 return false; 1072 } 1073 return true; 1074 } 1075 1076 @Override onDestroy()1077 public void onDestroy() { 1078 onListenerDisconnected(); 1079 super.onDestroy(); 1080 } 1081 1082 /** 1083 * Directly register this service with the Notification Manager. 1084 * 1085 * <p>Only system services may use this call. It will fail for non-system callers. 1086 * Apps should ask the user to add their listener in Settings. 1087 * 1088 * @param context Context required for accessing resources. Since this service isn't 1089 * launched as a real Service when using this method, a context has to be passed in. 1090 * @param componentName the component that will consume the notification information 1091 * @param currentUser the user to use as the stream filter 1092 * @hide 1093 * @removed 1094 */ 1095 @SystemApi registerAsSystemService(Context context, ComponentName componentName, int currentUser)1096 public void registerAsSystemService(Context context, ComponentName componentName, 1097 int currentUser) throws RemoteException { 1098 if (mWrapper == null) { 1099 mWrapper = new NotificationListenerWrapper(); 1100 } 1101 mSystemContext = context; 1102 INotificationManager noMan = getNotificationInterface(); 1103 mHandler = new MyHandler(context.getMainLooper()); 1104 mCurrentUser = currentUser; 1105 noMan.registerListener(mWrapper, componentName, currentUser); 1106 } 1107 1108 /** 1109 * Directly unregister this service from the Notification Manager. 1110 * 1111 * <p>This method will fail for listeners that were not registered 1112 * with (@link registerAsService). 1113 * @hide 1114 * @removed 1115 */ 1116 @SystemApi unregisterAsSystemService()1117 public void unregisterAsSystemService() throws RemoteException { 1118 if (mWrapper != null) { 1119 INotificationManager noMan = getNotificationInterface(); 1120 noMan.unregisterListener(mWrapper, mCurrentUser); 1121 } 1122 } 1123 1124 /** 1125 * Request that the listener be rebound, after a previous call to {@link #requestUnbind}. 1126 * 1127 * <p>This method will fail for listeners that have 1128 * not been granted the permission by the user. 1129 */ requestRebind(ComponentName componentName)1130 public static void requestRebind(ComponentName componentName) { 1131 INotificationManager noMan = INotificationManager.Stub.asInterface( 1132 ServiceManager.getService(Context.NOTIFICATION_SERVICE)); 1133 try { 1134 noMan.requestBindListener(componentName); 1135 } catch (RemoteException ex) { 1136 throw ex.rethrowFromSystemServer(); 1137 } 1138 } 1139 1140 /** 1141 * Request that the service be unbound. 1142 * 1143 * <p>Once this is called, you will no longer receive updates and no method calls are 1144 * guaranteed to be successful, until you next receive the {@link #onListenerConnected()} event. 1145 * The service will likely be killed by the system after this call. 1146 * 1147 * <p>The service should wait for the {@link #onListenerConnected()} event 1148 * before performing this operation. I know it's tempting, but you must wait. 1149 */ requestUnbind()1150 public final void requestUnbind() { 1151 if (mWrapper != null) { 1152 INotificationManager noMan = getNotificationInterface(); 1153 try { 1154 noMan.requestUnbindListener(mWrapper); 1155 // Disable future messages. 1156 isConnected = false; 1157 } catch (RemoteException ex) { 1158 throw ex.rethrowFromSystemServer(); 1159 } 1160 } 1161 } 1162 1163 /** Convert new-style Icons to legacy representations for pre-M clients. */ createLegacyIconExtras(Notification n)1164 private void createLegacyIconExtras(Notification n) { 1165 Icon smallIcon = n.getSmallIcon(); 1166 Icon largeIcon = n.getLargeIcon(); 1167 if (smallIcon != null && smallIcon.getType() == Icon.TYPE_RESOURCE) { 1168 n.extras.putInt(Notification.EXTRA_SMALL_ICON, smallIcon.getResId()); 1169 n.icon = smallIcon.getResId(); 1170 } 1171 if (largeIcon != null) { 1172 Drawable d = largeIcon.loadDrawable(getContext()); 1173 if (d != null && d instanceof BitmapDrawable) { 1174 final Bitmap largeIconBits = ((BitmapDrawable) d).getBitmap(); 1175 n.extras.putParcelable(Notification.EXTRA_LARGE_ICON, largeIconBits); 1176 n.largeIcon = largeIconBits; 1177 } 1178 } 1179 } 1180 1181 /** 1182 * Populates remote views for pre-N targeting apps. 1183 */ maybePopulateRemoteViews(Notification notification)1184 private void maybePopulateRemoteViews(Notification notification) { 1185 if (getContext().getApplicationInfo().targetSdkVersion < Build.VERSION_CODES.N) { 1186 Builder builder = Builder.recoverBuilder(getContext(), notification); 1187 1188 // Some styles wrap Notification's contentView, bigContentView and headsUpContentView. 1189 // First inflate them all, only then set them to avoid recursive wrapping. 1190 RemoteViews content = builder.createContentView(); 1191 RemoteViews big = builder.createBigContentView(); 1192 RemoteViews headsUp = builder.createHeadsUpContentView(); 1193 1194 notification.contentView = content; 1195 notification.bigContentView = big; 1196 notification.headsUpContentView = headsUp; 1197 } 1198 } 1199 1200 /** 1201 * Populates remote views for pre-P targeting apps. 1202 */ maybePopulatePeople(Notification notification)1203 private void maybePopulatePeople(Notification notification) { 1204 if (getContext().getApplicationInfo().targetSdkVersion < Build.VERSION_CODES.P) { 1205 ArrayList<Person> people = notification.extras.getParcelableArrayList( 1206 Notification.EXTRA_PEOPLE_LIST); 1207 if (people != null && people.isEmpty()) { 1208 int size = people.size(); 1209 String[] peopleArray = new String[size]; 1210 for (int i = 0; i < size; i++) { 1211 Person person = people.get(i); 1212 peopleArray[i] = person.resolveToLegacyUri(); 1213 } 1214 notification.extras.putStringArray(Notification.EXTRA_PEOPLE, peopleArray); 1215 } 1216 } 1217 } 1218 1219 /** @hide */ 1220 protected class NotificationListenerWrapper extends INotificationListener.Stub { 1221 @Override onNotificationPosted(IStatusBarNotificationHolder sbnHolder, NotificationRankingUpdate update)1222 public void onNotificationPosted(IStatusBarNotificationHolder sbnHolder, 1223 NotificationRankingUpdate update) { 1224 StatusBarNotification sbn; 1225 try { 1226 sbn = sbnHolder.get(); 1227 } catch (RemoteException e) { 1228 Log.w(TAG, "onNotificationPosted: Error receiving StatusBarNotification", e); 1229 return; 1230 } 1231 1232 try { 1233 // convert icon metadata to legacy format for older clients 1234 createLegacyIconExtras(sbn.getNotification()); 1235 maybePopulateRemoteViews(sbn.getNotification()); 1236 maybePopulatePeople(sbn.getNotification()); 1237 } catch (IllegalArgumentException e) { 1238 // warn and drop corrupt notification 1239 Log.w(TAG, "onNotificationPosted: can't rebuild notification from " + 1240 sbn.getPackageName()); 1241 sbn = null; 1242 } 1243 1244 // protect subclass from concurrent modifications of (@link mNotificationKeys}. 1245 synchronized (mLock) { 1246 applyUpdateLocked(update); 1247 if (sbn != null) { 1248 SomeArgs args = SomeArgs.obtain(); 1249 args.arg1 = sbn; 1250 args.arg2 = mRankingMap; 1251 mHandler.obtainMessage(MyHandler.MSG_ON_NOTIFICATION_POSTED, 1252 args).sendToTarget(); 1253 } else { 1254 // still pass along the ranking map, it may contain other information 1255 mHandler.obtainMessage(MyHandler.MSG_ON_NOTIFICATION_RANKING_UPDATE, 1256 mRankingMap).sendToTarget(); 1257 } 1258 } 1259 1260 } 1261 1262 @Override onNotificationRemoved(IStatusBarNotificationHolder sbnHolder, NotificationRankingUpdate update, NotificationStats stats, int reason)1263 public void onNotificationRemoved(IStatusBarNotificationHolder sbnHolder, 1264 NotificationRankingUpdate update, NotificationStats stats, int reason) { 1265 StatusBarNotification sbn; 1266 try { 1267 sbn = sbnHolder.get(); 1268 } catch (RemoteException e) { 1269 Log.w(TAG, "onNotificationRemoved: Error receiving StatusBarNotification", e); 1270 return; 1271 } 1272 // protect subclass from concurrent modifications of (@link mNotificationKeys}. 1273 synchronized (mLock) { 1274 applyUpdateLocked(update); 1275 SomeArgs args = SomeArgs.obtain(); 1276 args.arg1 = sbn; 1277 args.arg2 = mRankingMap; 1278 args.arg3 = reason; 1279 args.arg4 = stats; 1280 mHandler.obtainMessage(MyHandler.MSG_ON_NOTIFICATION_REMOVED, 1281 args).sendToTarget(); 1282 } 1283 1284 } 1285 1286 @Override onListenerConnected(NotificationRankingUpdate update)1287 public void onListenerConnected(NotificationRankingUpdate update) { 1288 // protect subclass from concurrent modifications of (@link mNotificationKeys}. 1289 synchronized (mLock) { 1290 applyUpdateLocked(update); 1291 } 1292 isConnected = true; 1293 mHandler.obtainMessage(MyHandler.MSG_ON_LISTENER_CONNECTED).sendToTarget(); 1294 } 1295 1296 @Override onNotificationRankingUpdate(NotificationRankingUpdate update)1297 public void onNotificationRankingUpdate(NotificationRankingUpdate update) 1298 throws RemoteException { 1299 // protect subclass from concurrent modifications of (@link mNotificationKeys}. 1300 synchronized (mLock) { 1301 applyUpdateLocked(update); 1302 mHandler.obtainMessage(MyHandler.MSG_ON_NOTIFICATION_RANKING_UPDATE, 1303 mRankingMap).sendToTarget(); 1304 } 1305 1306 } 1307 1308 @Override onListenerHintsChanged(int hints)1309 public void onListenerHintsChanged(int hints) throws RemoteException { 1310 mHandler.obtainMessage(MyHandler.MSG_ON_LISTENER_HINTS_CHANGED, 1311 hints, 0).sendToTarget(); 1312 } 1313 1314 @Override onInterruptionFilterChanged(int interruptionFilter)1315 public void onInterruptionFilterChanged(int interruptionFilter) throws RemoteException { 1316 mHandler.obtainMessage(MyHandler.MSG_ON_INTERRUPTION_FILTER_CHANGED, 1317 interruptionFilter, 0).sendToTarget(); 1318 } 1319 1320 @Override onNotificationEnqueued(IStatusBarNotificationHolder notificationHolder)1321 public void onNotificationEnqueued(IStatusBarNotificationHolder notificationHolder) 1322 throws RemoteException { 1323 // no-op in the listener 1324 } 1325 1326 @Override onNotificationSnoozedUntilContext( IStatusBarNotificationHolder notificationHolder, String snoozeCriterionId)1327 public void onNotificationSnoozedUntilContext( 1328 IStatusBarNotificationHolder notificationHolder, String snoozeCriterionId) 1329 throws RemoteException { 1330 // no-op in the listener 1331 } 1332 1333 @Override onNotificationChannelModification(String pkgName, UserHandle user, NotificationChannel channel, @ChannelOrGroupModificationTypes int modificationType)1334 public void onNotificationChannelModification(String pkgName, UserHandle user, 1335 NotificationChannel channel, 1336 @ChannelOrGroupModificationTypes int modificationType) { 1337 SomeArgs args = SomeArgs.obtain(); 1338 args.arg1 = pkgName; 1339 args.arg2 = user; 1340 args.arg3 = channel; 1341 args.arg4 = modificationType; 1342 mHandler.obtainMessage( 1343 MyHandler.MSG_ON_NOTIFICATION_CHANNEL_MODIFIED, args).sendToTarget(); 1344 } 1345 1346 @Override onNotificationChannelGroupModification(String pkgName, UserHandle user, NotificationChannelGroup group, @ChannelOrGroupModificationTypes int modificationType)1347 public void onNotificationChannelGroupModification(String pkgName, UserHandle user, 1348 NotificationChannelGroup group, 1349 @ChannelOrGroupModificationTypes int modificationType) { 1350 SomeArgs args = SomeArgs.obtain(); 1351 args.arg1 = pkgName; 1352 args.arg2 = user; 1353 args.arg3 = group; 1354 args.arg4 = modificationType; 1355 mHandler.obtainMessage( 1356 MyHandler.MSG_ON_NOTIFICATION_CHANNEL_GROUP_MODIFIED, args).sendToTarget(); 1357 } 1358 } 1359 1360 /** 1361 * @hide 1362 */ 1363 @GuardedBy("mLock") applyUpdateLocked(NotificationRankingUpdate update)1364 public final void applyUpdateLocked(NotificationRankingUpdate update) { 1365 mRankingMap = new RankingMap(update); 1366 } 1367 1368 /** @hide */ getContext()1369 protected Context getContext() { 1370 if (mSystemContext != null) { 1371 return mSystemContext; 1372 } 1373 return this; 1374 } 1375 1376 /** 1377 * Stores ranking related information on a currently active notification. 1378 * 1379 * <p> 1380 * Ranking objects aren't automatically updated as notification events 1381 * occur. Instead, ranking information has to be retrieved again via the 1382 * current {@link RankingMap}. 1383 */ 1384 public static class Ranking { 1385 1386 /** Value signifying that the user has not expressed a per-app visibility override value. 1387 * @hide */ 1388 public static final int VISIBILITY_NO_OVERRIDE = NotificationManager.VISIBILITY_NO_OVERRIDE; 1389 1390 /** 1391 * The user is likely to have a negative reaction to this notification. 1392 */ 1393 public static final int USER_SENTIMENT_NEGATIVE = -1; 1394 /** 1395 * It is not known how the user will react to this notification. 1396 */ 1397 public static final int USER_SENTIMENT_NEUTRAL = 0; 1398 /** 1399 * The user is likely to have a positive reaction to this notification. 1400 */ 1401 public static final int USER_SENTIMENT_POSITIVE = 1; 1402 1403 /** @hide */ 1404 @IntDef(prefix = { "USER_SENTIMENT_" }, value = { 1405 USER_SENTIMENT_NEGATIVE, USER_SENTIMENT_NEUTRAL, USER_SENTIMENT_POSITIVE 1406 }) 1407 @Retention(RetentionPolicy.SOURCE) 1408 public @interface UserSentiment {} 1409 1410 private String mKey; 1411 private int mRank = -1; 1412 private boolean mIsAmbient; 1413 private boolean mMatchesInterruptionFilter; 1414 private int mVisibilityOverride; 1415 private int mSuppressedVisualEffects; 1416 private @NotificationManager.Importance int mImportance; 1417 private CharSequence mImportanceExplanation; 1418 // System specified group key. 1419 private String mOverrideGroupKey; 1420 // Notification assistant channel override. 1421 private NotificationChannel mChannel; 1422 // Notification assistant people override. 1423 private ArrayList<String> mOverridePeople; 1424 // Notification assistant snooze criteria. 1425 private ArrayList<SnoozeCriterion> mSnoozeCriteria; 1426 private boolean mShowBadge; 1427 private @UserSentiment int mUserSentiment = USER_SENTIMENT_NEUTRAL; 1428 private boolean mHidden; 1429 Ranking()1430 public Ranking() {} 1431 1432 /** 1433 * Returns the key of the notification this Ranking applies to. 1434 */ getKey()1435 public String getKey() { 1436 return mKey; 1437 } 1438 1439 /** 1440 * Returns the rank of the notification. 1441 * 1442 * @return the rank of the notification, that is the 0-based index in 1443 * the list of active notifications. 1444 */ getRank()1445 public int getRank() { 1446 return mRank; 1447 } 1448 1449 /** 1450 * Returns whether the notification is an ambient notification, that is 1451 * a notification that doesn't require the user's immediate attention. 1452 */ isAmbient()1453 public boolean isAmbient() { 1454 return mIsAmbient; 1455 } 1456 1457 /** 1458 * Returns the user specified visibility for the package that posted 1459 * this notification, or 1460 * {@link NotificationListenerService.Ranking#VISIBILITY_NO_OVERRIDE} if 1461 * no such preference has been expressed. 1462 * @hide 1463 */ getVisibilityOverride()1464 public int getVisibilityOverride() { 1465 return mVisibilityOverride; 1466 } 1467 1468 /** 1469 * Returns the type(s) of visual effects that should be suppressed for this notification. 1470 * See {@link NotificationManager.Policy}, e.g. 1471 * {@link NotificationManager.Policy#SUPPRESSED_EFFECT_LIGHTS}. 1472 */ getSuppressedVisualEffects()1473 public int getSuppressedVisualEffects() { 1474 return mSuppressedVisualEffects; 1475 } 1476 1477 /** 1478 * Returns whether the notification matches the user's interruption 1479 * filter. 1480 * 1481 * @return {@code true} if the notification is allowed by the filter, or 1482 * {@code false} if it is blocked. 1483 */ matchesInterruptionFilter()1484 public boolean matchesInterruptionFilter() { 1485 return mMatchesInterruptionFilter; 1486 } 1487 1488 /** 1489 * Returns the importance of the notification, which dictates its 1490 * modes of presentation, see: {@link NotificationManager#IMPORTANCE_DEFAULT}, etc. 1491 * 1492 * @return the importance of the notification 1493 */ getImportance()1494 public @NotificationManager.Importance int getImportance() { 1495 return mImportance; 1496 } 1497 1498 /** 1499 * If the importance has been overridden by user preference, then this will be non-null, 1500 * and should be displayed to the user. 1501 * 1502 * @return the explanation for the importance, or null if it is the natural importance 1503 */ getImportanceExplanation()1504 public CharSequence getImportanceExplanation() { 1505 return mImportanceExplanation; 1506 } 1507 1508 /** 1509 * If the system has overridden the group key, then this will be non-null, and this 1510 * key should be used to bundle notifications. 1511 */ getOverrideGroupKey()1512 public String getOverrideGroupKey() { 1513 return mOverrideGroupKey; 1514 } 1515 1516 /** 1517 * Returns the notification channel this notification was posted to, which dictates 1518 * notification behavior and presentation. 1519 */ getChannel()1520 public NotificationChannel getChannel() { 1521 return mChannel; 1522 } 1523 1524 /** 1525 * Returns how the system thinks the user feels about notifications from the 1526 * channel provided by {@link #getChannel()}. You can use this information to expose 1527 * controls to help the user block this channel's notifications, if the sentiment is 1528 * {@link #USER_SENTIMENT_NEGATIVE}, or emphasize this notification if the sentiment is 1529 * {@link #USER_SENTIMENT_POSITIVE}. 1530 */ getUserSentiment()1531 public int getUserSentiment() { 1532 return mUserSentiment; 1533 } 1534 1535 /** 1536 * If the {@link NotificationAssistantService} has added people to this notification, then 1537 * this will be non-null. 1538 * @hide 1539 * @removed 1540 */ 1541 @SystemApi getAdditionalPeople()1542 public List<String> getAdditionalPeople() { 1543 return mOverridePeople; 1544 } 1545 1546 /** 1547 * Returns snooze criteria provided by the {@link NotificationAssistantService}. If your 1548 * user interface displays options for snoozing notifications these criteria should be 1549 * displayed as well. 1550 * @hide 1551 * @removed 1552 */ 1553 @SystemApi getSnoozeCriteria()1554 public List<SnoozeCriterion> getSnoozeCriteria() { 1555 return mSnoozeCriteria; 1556 } 1557 1558 /** 1559 * Returns whether this notification can be displayed as a badge. 1560 * 1561 * @return true if the notification can be displayed as a badge, false otherwise. 1562 */ canShowBadge()1563 public boolean canShowBadge() { 1564 return mShowBadge; 1565 } 1566 1567 /** 1568 * Returns whether the app that posted this notification is suspended, so this notification 1569 * should be hidden. 1570 * 1571 * @return true if the notification should be hidden, false otherwise. 1572 */ isSuspended()1573 public boolean isSuspended() { 1574 return mHidden; 1575 } 1576 1577 /** 1578 * @hide 1579 */ 1580 @VisibleForTesting populate(String key, int rank, boolean matchesInterruptionFilter, int visibilityOverride, int suppressedVisualEffects, int importance, CharSequence explanation, String overrideGroupKey, NotificationChannel channel, ArrayList<String> overridePeople, ArrayList<SnoozeCriterion> snoozeCriteria, boolean showBadge, int userSentiment, boolean hidden)1581 public void populate(String key, int rank, boolean matchesInterruptionFilter, 1582 int visibilityOverride, int suppressedVisualEffects, int importance, 1583 CharSequence explanation, String overrideGroupKey, 1584 NotificationChannel channel, ArrayList<String> overridePeople, 1585 ArrayList<SnoozeCriterion> snoozeCriteria, boolean showBadge, 1586 int userSentiment, boolean hidden) { 1587 mKey = key; 1588 mRank = rank; 1589 mIsAmbient = importance < NotificationManager.IMPORTANCE_LOW; 1590 mMatchesInterruptionFilter = matchesInterruptionFilter; 1591 mVisibilityOverride = visibilityOverride; 1592 mSuppressedVisualEffects = suppressedVisualEffects; 1593 mImportance = importance; 1594 mImportanceExplanation = explanation; 1595 mOverrideGroupKey = overrideGroupKey; 1596 mChannel = channel; 1597 mOverridePeople = overridePeople; 1598 mSnoozeCriteria = snoozeCriteria; 1599 mShowBadge = showBadge; 1600 mUserSentiment = userSentiment; 1601 mHidden = hidden; 1602 } 1603 1604 /** 1605 * {@hide} 1606 */ 1607 public static String importanceToString(int importance) { 1608 switch (importance) { 1609 case NotificationManager.IMPORTANCE_UNSPECIFIED: 1610 return "UNSPECIFIED"; 1611 case NotificationManager.IMPORTANCE_NONE: 1612 return "NONE"; 1613 case NotificationManager.IMPORTANCE_MIN: 1614 return "MIN"; 1615 case NotificationManager.IMPORTANCE_LOW: 1616 return "LOW"; 1617 case NotificationManager.IMPORTANCE_DEFAULT: 1618 return "DEFAULT"; 1619 case NotificationManager.IMPORTANCE_HIGH: 1620 case NotificationManager.IMPORTANCE_MAX: 1621 return "HIGH"; 1622 default: 1623 return "UNKNOWN(" + String.valueOf(importance) + ")"; 1624 } 1625 } 1626 } 1627 1628 /** 1629 * Provides access to ranking information on currently active 1630 * notifications. 1631 * 1632 * <p> 1633 * Note that this object represents a ranking snapshot that only applies to 1634 * notifications active at the time of retrieval. 1635 */ 1636 public static class RankingMap implements Parcelable { 1637 private final NotificationRankingUpdate mRankingUpdate; 1638 private ArrayMap<String,Integer> mRanks; 1639 private ArraySet<Object> mIntercepted; 1640 private ArrayMap<String, Integer> mVisibilityOverrides; 1641 private ArrayMap<String, Integer> mSuppressedVisualEffects; 1642 private ArrayMap<String, Integer> mImportance; 1643 private ArrayMap<String, String> mImportanceExplanation; 1644 private ArrayMap<String, String> mOverrideGroupKeys; 1645 private ArrayMap<String, NotificationChannel> mChannels; 1646 private ArrayMap<String, ArrayList<String>> mOverridePeople; 1647 private ArrayMap<String, ArrayList<SnoozeCriterion>> mSnoozeCriteria; 1648 private ArrayMap<String, Boolean> mShowBadge; 1649 private ArrayMap<String, Integer> mUserSentiment; 1650 private ArrayMap<String, Boolean> mHidden; 1651 1652 private RankingMap(NotificationRankingUpdate rankingUpdate) { 1653 mRankingUpdate = rankingUpdate; 1654 } 1655 1656 /** 1657 * Request the list of notification keys in their current ranking 1658 * order. 1659 * 1660 * @return An array of active notification keys, in their ranking order. 1661 */ 1662 public String[] getOrderedKeys() { 1663 return mRankingUpdate.getOrderedKeys(); 1664 } 1665 1666 /** 1667 * Populates outRanking with ranking information for the notification 1668 * with the given key. 1669 * 1670 * @return true if a valid key has been passed and outRanking has 1671 * been populated; false otherwise 1672 */ 1673 public boolean getRanking(String key, Ranking outRanking) { 1674 int rank = getRank(key); 1675 outRanking.populate(key, rank, !isIntercepted(key), 1676 getVisibilityOverride(key), getSuppressedVisualEffects(key), 1677 getImportance(key), getImportanceExplanation(key), getOverrideGroupKey(key), 1678 getChannel(key), getOverridePeople(key), getSnoozeCriteria(key), 1679 getShowBadge(key), getUserSentiment(key), getHidden(key)); 1680 return rank >= 0; 1681 } 1682 getRank(String key)1683 private int getRank(String key) { 1684 synchronized (this) { 1685 if (mRanks == null) { 1686 buildRanksLocked(); 1687 } 1688 } 1689 Integer rank = mRanks.get(key); 1690 return rank != null ? rank : -1; 1691 } 1692 isIntercepted(String key)1693 private boolean isIntercepted(String key) { 1694 synchronized (this) { 1695 if (mIntercepted == null) { 1696 buildInterceptedSetLocked(); 1697 } 1698 } 1699 return mIntercepted.contains(key); 1700 } 1701 getVisibilityOverride(String key)1702 private int getVisibilityOverride(String key) { 1703 synchronized (this) { 1704 if (mVisibilityOverrides == null) { 1705 buildVisibilityOverridesLocked(); 1706 } 1707 } 1708 Integer override = mVisibilityOverrides.get(key); 1709 if (override == null) { 1710 return Ranking.VISIBILITY_NO_OVERRIDE; 1711 } 1712 return override.intValue(); 1713 } 1714 getSuppressedVisualEffects(String key)1715 private int getSuppressedVisualEffects(String key) { 1716 synchronized (this) { 1717 if (mSuppressedVisualEffects == null) { 1718 buildSuppressedVisualEffectsLocked(); 1719 } 1720 } 1721 Integer suppressed = mSuppressedVisualEffects.get(key); 1722 if (suppressed == null) { 1723 return 0; 1724 } 1725 return suppressed.intValue(); 1726 } 1727 getImportance(String key)1728 private int getImportance(String key) { 1729 synchronized (this) { 1730 if (mImportance == null) { 1731 buildImportanceLocked(); 1732 } 1733 } 1734 Integer importance = mImportance.get(key); 1735 if (importance == null) { 1736 return NotificationManager.IMPORTANCE_DEFAULT; 1737 } 1738 return importance.intValue(); 1739 } 1740 getImportanceExplanation(String key)1741 private String getImportanceExplanation(String key) { 1742 synchronized (this) { 1743 if (mImportanceExplanation == null) { 1744 buildImportanceExplanationLocked(); 1745 } 1746 } 1747 return mImportanceExplanation.get(key); 1748 } 1749 getOverrideGroupKey(String key)1750 private String getOverrideGroupKey(String key) { 1751 synchronized (this) { 1752 if (mOverrideGroupKeys == null) { 1753 buildOverrideGroupKeys(); 1754 } 1755 } 1756 return mOverrideGroupKeys.get(key); 1757 } 1758 getChannel(String key)1759 private NotificationChannel getChannel(String key) { 1760 synchronized (this) { 1761 if (mChannels == null) { 1762 buildChannelsLocked(); 1763 } 1764 } 1765 return mChannels.get(key); 1766 } 1767 getOverridePeople(String key)1768 private ArrayList<String> getOverridePeople(String key) { 1769 synchronized (this) { 1770 if (mOverridePeople == null) { 1771 buildOverridePeopleLocked(); 1772 } 1773 } 1774 return mOverridePeople.get(key); 1775 } 1776 getSnoozeCriteria(String key)1777 private ArrayList<SnoozeCriterion> getSnoozeCriteria(String key) { 1778 synchronized (this) { 1779 if (mSnoozeCriteria == null) { 1780 buildSnoozeCriteriaLocked(); 1781 } 1782 } 1783 return mSnoozeCriteria.get(key); 1784 } 1785 getShowBadge(String key)1786 private boolean getShowBadge(String key) { 1787 synchronized (this) { 1788 if (mShowBadge == null) { 1789 buildShowBadgeLocked(); 1790 } 1791 } 1792 Boolean showBadge = mShowBadge.get(key); 1793 return showBadge == null ? false : showBadge.booleanValue(); 1794 } 1795 getUserSentiment(String key)1796 private int getUserSentiment(String key) { 1797 synchronized (this) { 1798 if (mUserSentiment == null) { 1799 buildUserSentimentLocked(); 1800 } 1801 } 1802 Integer userSentiment = mUserSentiment.get(key); 1803 return userSentiment == null 1804 ? Ranking.USER_SENTIMENT_NEUTRAL : userSentiment.intValue(); 1805 } 1806 getHidden(String key)1807 private boolean getHidden(String key) { 1808 synchronized (this) { 1809 if (mHidden == null) { 1810 buildHiddenLocked(); 1811 } 1812 } 1813 Boolean hidden = mHidden.get(key); 1814 return hidden == null ? false : hidden.booleanValue(); 1815 } 1816 1817 // Locked by 'this' buildRanksLocked()1818 private void buildRanksLocked() { 1819 String[] orderedKeys = mRankingUpdate.getOrderedKeys(); 1820 mRanks = new ArrayMap<>(orderedKeys.length); 1821 for (int i = 0; i < orderedKeys.length; i++) { 1822 String key = orderedKeys[i]; 1823 mRanks.put(key, i); 1824 } 1825 } 1826 1827 // Locked by 'this' buildInterceptedSetLocked()1828 private void buildInterceptedSetLocked() { 1829 String[] dndInterceptedKeys = mRankingUpdate.getInterceptedKeys(); 1830 mIntercepted = new ArraySet<>(dndInterceptedKeys.length); 1831 Collections.addAll(mIntercepted, dndInterceptedKeys); 1832 } 1833 1834 // Locked by 'this' buildVisibilityOverridesLocked()1835 private void buildVisibilityOverridesLocked() { 1836 Bundle visibilityBundle = mRankingUpdate.getVisibilityOverrides(); 1837 mVisibilityOverrides = new ArrayMap<>(visibilityBundle.size()); 1838 for (String key: visibilityBundle.keySet()) { 1839 mVisibilityOverrides.put(key, visibilityBundle.getInt(key)); 1840 } 1841 } 1842 1843 // Locked by 'this' buildSuppressedVisualEffectsLocked()1844 private void buildSuppressedVisualEffectsLocked() { 1845 Bundle suppressedBundle = mRankingUpdate.getSuppressedVisualEffects(); 1846 mSuppressedVisualEffects = new ArrayMap<>(suppressedBundle.size()); 1847 for (String key: suppressedBundle.keySet()) { 1848 mSuppressedVisualEffects.put(key, suppressedBundle.getInt(key)); 1849 } 1850 } 1851 // Locked by 'this' buildImportanceLocked()1852 private void buildImportanceLocked() { 1853 String[] orderedKeys = mRankingUpdate.getOrderedKeys(); 1854 int[] importance = mRankingUpdate.getImportance(); 1855 mImportance = new ArrayMap<>(orderedKeys.length); 1856 for (int i = 0; i < orderedKeys.length; i++) { 1857 String key = orderedKeys[i]; 1858 mImportance.put(key, importance[i]); 1859 } 1860 } 1861 1862 // Locked by 'this' buildImportanceExplanationLocked()1863 private void buildImportanceExplanationLocked() { 1864 Bundle explanationBundle = mRankingUpdate.getImportanceExplanation(); 1865 mImportanceExplanation = new ArrayMap<>(explanationBundle.size()); 1866 for (String key: explanationBundle.keySet()) { 1867 mImportanceExplanation.put(key, explanationBundle.getString(key)); 1868 } 1869 } 1870 1871 // Locked by 'this' buildOverrideGroupKeys()1872 private void buildOverrideGroupKeys() { 1873 Bundle overrideGroupKeys = mRankingUpdate.getOverrideGroupKeys(); 1874 mOverrideGroupKeys = new ArrayMap<>(overrideGroupKeys.size()); 1875 for (String key: overrideGroupKeys.keySet()) { 1876 mOverrideGroupKeys.put(key, overrideGroupKeys.getString(key)); 1877 } 1878 } 1879 1880 // Locked by 'this' buildChannelsLocked()1881 private void buildChannelsLocked() { 1882 Bundle channels = mRankingUpdate.getChannels(); 1883 mChannels = new ArrayMap<>(channels.size()); 1884 for (String key : channels.keySet()) { 1885 mChannels.put(key, channels.getParcelable(key)); 1886 } 1887 } 1888 1889 // Locked by 'this' buildOverridePeopleLocked()1890 private void buildOverridePeopleLocked() { 1891 Bundle overridePeople = mRankingUpdate.getOverridePeople(); 1892 mOverridePeople = new ArrayMap<>(overridePeople.size()); 1893 for (String key : overridePeople.keySet()) { 1894 mOverridePeople.put(key, overridePeople.getStringArrayList(key)); 1895 } 1896 } 1897 1898 // Locked by 'this' buildSnoozeCriteriaLocked()1899 private void buildSnoozeCriteriaLocked() { 1900 Bundle snoozeCriteria = mRankingUpdate.getSnoozeCriteria(); 1901 mSnoozeCriteria = new ArrayMap<>(snoozeCriteria.size()); 1902 for (String key : snoozeCriteria.keySet()) { 1903 mSnoozeCriteria.put(key, snoozeCriteria.getParcelableArrayList(key)); 1904 } 1905 } 1906 1907 // Locked by 'this' buildShowBadgeLocked()1908 private void buildShowBadgeLocked() { 1909 Bundle showBadge = mRankingUpdate.getShowBadge(); 1910 mShowBadge = new ArrayMap<>(showBadge.size()); 1911 for (String key : showBadge.keySet()) { 1912 mShowBadge.put(key, showBadge.getBoolean(key)); 1913 } 1914 } 1915 1916 // Locked by 'this' buildUserSentimentLocked()1917 private void buildUserSentimentLocked() { 1918 Bundle userSentiment = mRankingUpdate.getUserSentiment(); 1919 mUserSentiment = new ArrayMap<>(userSentiment.size()); 1920 for (String key : userSentiment.keySet()) { 1921 mUserSentiment.put(key, userSentiment.getInt(key)); 1922 } 1923 } 1924 1925 // Locked by 'this' buildHiddenLocked()1926 private void buildHiddenLocked() { 1927 Bundle hidden = mRankingUpdate.getHidden(); 1928 mHidden = new ArrayMap<>(hidden.size()); 1929 for (String key : hidden.keySet()) { 1930 mHidden.put(key, hidden.getBoolean(key)); 1931 } 1932 } 1933 1934 // ----------- Parcelable 1935 1936 @Override describeContents()1937 public int describeContents() { 1938 return 0; 1939 } 1940 1941 @Override writeToParcel(Parcel dest, int flags)1942 public void writeToParcel(Parcel dest, int flags) { 1943 dest.writeParcelable(mRankingUpdate, flags); 1944 } 1945 1946 public static final Creator<RankingMap> CREATOR = new Creator<RankingMap>() { 1947 @Override 1948 public RankingMap createFromParcel(Parcel source) { 1949 NotificationRankingUpdate rankingUpdate = source.readParcelable(null); 1950 return new RankingMap(rankingUpdate); 1951 } 1952 1953 @Override 1954 public RankingMap[] newArray(int size) { 1955 return new RankingMap[size]; 1956 } 1957 }; 1958 } 1959 1960 private final class MyHandler extends Handler { 1961 public static final int MSG_ON_NOTIFICATION_POSTED = 1; 1962 public static final int MSG_ON_NOTIFICATION_REMOVED = 2; 1963 public static final int MSG_ON_LISTENER_CONNECTED = 3; 1964 public static final int MSG_ON_NOTIFICATION_RANKING_UPDATE = 4; 1965 public static final int MSG_ON_LISTENER_HINTS_CHANGED = 5; 1966 public static final int MSG_ON_INTERRUPTION_FILTER_CHANGED = 6; 1967 public static final int MSG_ON_NOTIFICATION_CHANNEL_MODIFIED = 7; 1968 public static final int MSG_ON_NOTIFICATION_CHANNEL_GROUP_MODIFIED = 8; 1969 MyHandler(Looper looper)1970 public MyHandler(Looper looper) { 1971 super(looper, null, false); 1972 } 1973 1974 @Override handleMessage(Message msg)1975 public void handleMessage(Message msg) { 1976 if (!isConnected) { 1977 return; 1978 } 1979 switch (msg.what) { 1980 case MSG_ON_NOTIFICATION_POSTED: { 1981 SomeArgs args = (SomeArgs) msg.obj; 1982 StatusBarNotification sbn = (StatusBarNotification) args.arg1; 1983 RankingMap rankingMap = (RankingMap) args.arg2; 1984 args.recycle(); 1985 onNotificationPosted(sbn, rankingMap); 1986 } break; 1987 1988 case MSG_ON_NOTIFICATION_REMOVED: { 1989 SomeArgs args = (SomeArgs) msg.obj; 1990 StatusBarNotification sbn = (StatusBarNotification) args.arg1; 1991 RankingMap rankingMap = (RankingMap) args.arg2; 1992 int reason = (int) args.arg3; 1993 NotificationStats stats = (NotificationStats) args.arg4; 1994 args.recycle(); 1995 onNotificationRemoved(sbn, rankingMap, stats, reason); 1996 } break; 1997 1998 case MSG_ON_LISTENER_CONNECTED: { 1999 onListenerConnected(); 2000 } break; 2001 2002 case MSG_ON_NOTIFICATION_RANKING_UPDATE: { 2003 RankingMap rankingMap = (RankingMap) msg.obj; 2004 onNotificationRankingUpdate(rankingMap); 2005 } break; 2006 2007 case MSG_ON_LISTENER_HINTS_CHANGED: { 2008 final int hints = msg.arg1; 2009 onListenerHintsChanged(hints); 2010 } break; 2011 2012 case MSG_ON_INTERRUPTION_FILTER_CHANGED: { 2013 final int interruptionFilter = msg.arg1; 2014 onInterruptionFilterChanged(interruptionFilter); 2015 } break; 2016 2017 case MSG_ON_NOTIFICATION_CHANNEL_MODIFIED: { 2018 SomeArgs args = (SomeArgs) msg.obj; 2019 String pkgName = (String) args.arg1; 2020 UserHandle user= (UserHandle) args.arg2; 2021 NotificationChannel channel = (NotificationChannel) args.arg3; 2022 int modificationType = (int) args.arg4; 2023 onNotificationChannelModified(pkgName, user, channel, modificationType); 2024 } break; 2025 2026 case MSG_ON_NOTIFICATION_CHANNEL_GROUP_MODIFIED: { 2027 SomeArgs args = (SomeArgs) msg.obj; 2028 String pkgName = (String) args.arg1; 2029 UserHandle user = (UserHandle) args.arg2; 2030 NotificationChannelGroup group = (NotificationChannelGroup) args.arg3; 2031 int modificationType = (int) args.arg4; 2032 onNotificationChannelGroupModified(pkgName, user, group, modificationType); 2033 } break; 2034 } 2035 } 2036 } 2037 } 2038