packages/SystemUI/src/com/android/systemui/statusbar/phone/NotificationGroupManager.java

   1 /*
   2  * Copyright (C) 2015 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 com.android.systemui.statusbar.phone;
  18
  19 import android.app.Notification;
  20 import android.os.SystemClock;
  21 import android.service.notification.StatusBarNotification;
  22 import androidx.annotation.Nullable;
  23 import android.util.Log;
  24
  25 import com.android.systemui.statusbar.ExpandableNotificationRow;
  26 import com.android.systemui.statusbar.NotificationData;
  27 import com.android.systemui.statusbar.StatusBarState;
  28 import com.android.systemui.statusbar.policy.HeadsUpManager;
  29 import com.android.systemui.statusbar.policy.OnHeadsUpChangedListener;
  30
  31 import java.io.FileDescriptor;
  32 import java.io.PrintWriter;
  33 import java.util.ArrayList;
  34 import java.util.Collection;
  35 import java.util.HashMap;
  36 import java.util.Iterator;
  37 import java.util.Map;
  38 import java.util.Objects;
  39
  40 /**
  41  * A class to handle notifications and their corresponding groups.
  42  */
  43 public class NotificationGroupManager implements OnHeadsUpChangedListener {
  44
  45     private static final String TAG = "NotificationGroupManager";
  46     private static final long HEADS_UP_TRANSFER_TIMEOUT = 300;
  47     private final HashMap<String, NotificationGroup> mGroupMap = new HashMap<>();
  48     private OnGroupChangeListener mListener;
  49     private int mBarState = -1;
  50     private HashMap<String, StatusBarNotification> mIsolatedEntries = new HashMap<>();
  51     private HeadsUpManager mHeadsUpManager;
  52     private boolean mIsUpdatingUnchangedGroup;
  53     private HashMap<String, NotificationData.Entry> mPendingNotifications;
  54
  55     public void setOnGroupChangeListener(OnGroupChangeListener listener) {
  56         mListener = listener;
  57     }
  58
  59     public boolean isGroupExpanded(StatusBarNotification sbn) {
  60         NotificationGroup group = mGroupMap.get(getGroupKey(sbn));
  61         if (group == null) {
  62             return false;
  63         }
  64         return group.expanded;
  65     }
  66
  67     public void setGroupExpanded(StatusBarNotification sbn, boolean expanded) {
  68         NotificationGroup group = mGroupMap.get(getGroupKey(sbn));
  69         if (group == null) {
  70             return;
  71         }
  72         setGroupExpanded(group, expanded);
  73     }
  74
  75     private void setGroupExpanded(NotificationGroup group, boolean expanded) {
  76         group.expanded = expanded;
  77         if (group.summary != null) {
  78             mListener.onGroupExpansionChanged(group.summary.row, expanded);
  79         }
  80     }
  81
  82     public void onEntryRemoved(NotificationData.Entry removed) {
  83         onEntryRemovedInternal(removed, removed.notification);
  84         mIsolatedEntries.remove(removed.key);
  85     }
  86
  87     /**
  88      * An entry was removed.
  89      *
  90      * @param removed the removed entry
  91      * @param sbn the notification the entry has, which doesn't need to be the same as it's internal
  92      *            notification
  93      */
  94     private void onEntryRemovedInternal(NotificationData.Entry removed,
  95             final StatusBarNotification sbn) {
  96         String groupKey = getGroupKey(sbn);
  97         final NotificationGroup group = mGroupMap.get(groupKey);
  98         if (group == null) {
  99             // When an app posts 2 different notifications as summary of the same group, then a
 100             // cancellation of the first notification removes this group.
 101             // This situation is not supported and we will not allow such notifications anymore in
 102             // the close future. See b/23676310 for reference.
 103             return;
 104         }
 105         if (isGroupChild(sbn)) {
 106             group.children.remove(removed.key);
 107         } else {
 108             group.summary = null;
 109         }
 110         updateSuppression(group);
 111         if (group.children.isEmpty()) {
 112             if (group.summary == null) {
 113                 mGroupMap.remove(groupKey);
 114             }
 115         }
 116     }
 117
 118     public void onEntryAdded(final NotificationData.Entry added) {
 119         if (added.row.isRemoved()) {
 120             added.setDebugThrowable(new Throwable());
 121         }
 122         final StatusBarNotification sbn = added.notification;
 123         boolean isGroupChild = isGroupChild(sbn);
 124         String groupKey = getGroupKey(sbn);
 125         NotificationGroup group = mGroupMap.get(groupKey);
 126         if (group == null) {
 127             group = new NotificationGroup();
 128             mGroupMap.put(groupKey, group);
 129         }
 130         if (isGroupChild) {
 131             NotificationData.Entry existing = group.children.get(added.key);
 132             if (existing != null && existing != added) {
 133                 Throwable existingThrowable = existing.getDebugThrowable();
 134                 Log.wtf(TAG, "Inconsistent entries found with the same key " + added.key
 135                         + "existing removed: " + existing.row.isRemoved()
 136                         + (existingThrowable != null
 137                                 ? Log.getStackTraceString(existingThrowable) + "\n": "")
 138                         + " added removed" + added.row.isRemoved()
 139                         , new Throwable());
 140             }
 141             group.children.put(added.key, added);
 142             updateSuppression(group);
 143         } else {
 144             group.summary = added;
 145             group.expanded = added.row.areChildrenExpanded();
 146             updateSuppression(group);
 147             if (!group.children.isEmpty()) {
 148                 ArrayList<NotificationData.Entry> childrenCopy
 149                         = new ArrayList<>(group.children.values());
 150                 for (NotificationData.Entry child : childrenCopy) {
 151                     onEntryBecomingChild(child);
 152                 }
 153                 mListener.onGroupCreatedFromChildren(group);
 154             }
 155         }
 156         cleanUpHeadsUpStatesOnAdd(group, false /* addIsPending */);
 157     }
 158
 159     public void onPendingEntryAdded(NotificationData.Entry shadeEntry) {
 160         String groupKey = getGroupKey(shadeEntry.notification);
 161         NotificationGroup group = mGroupMap.get(groupKey);
 162         if (group != null) {
 163             cleanUpHeadsUpStatesOnAdd(group, true /* addIsPending */);
 164         }
 165     }
 166
 167     /**
 168      * Clean up the heads up states when a new child was added.
 169      * @param group The group where a view was added or will be added.
 170      * @param addIsPending True if is the addition still pending or false has it already been added.
 171      */
 172     private void cleanUpHeadsUpStatesOnAdd(NotificationGroup group, boolean addIsPending) {
 173         if (!addIsPending && group.hunSummaryOnNextAddition) {
 174             if (!mHeadsUpManager.isHeadsUp(group.summary.key)) {
 175                 mHeadsUpManager.showNotification(group.summary);
 176             }
 177             group.hunSummaryOnNextAddition = false;
 178         }
 179         // Because notification groups are not delivered as a whole unit, it may happen that a
 180         // group child gets added quite a bit after the summary got posted. Our guidance is, that
 181         // apps should always post the group summary as well and we'll hide it for them if the child
 182         // is the only child in a group. Because of this, we also have to transfer heads up to the
 183         // child, otherwise the invisible summary would be heads-upped.
 184         // This transfer to the child is not always correct in case the app has just posted another
 185         // child in addition to the existing one, but it hasn't arrived in systemUI yet. In such
 186         // a scenario we would transfer the heads up to the old child and the wrong notification
 187         // would be heads-upped. In oder to avoid this, we'll recover from this issue and hun the
 188         // summary again instead of the old child if it's within a certain timeout.
 189         if (SystemClock.elapsedRealtime() - group.lastHeadsUpTransfer < HEADS_UP_TRANSFER_TIMEOUT) {
 190             if (!onlySummaryAlerts(group.summary)) {
 191                 return;
 192             }
 193             int numChildren = group.children.size();
 194             NotificationData.Entry isolatedChild = getIsolatedChild(getGroupKey(
 195                     group.summary.notification));
 196             int numPendingChildren = getPendingChildrenNotAlerting(group);
 197             numChildren += numPendingChildren;
 198             if (isolatedChild != null) {
 199                 numChildren++;
 200             }
 201             if (numChildren <= 1) {
 202                 return;
 203             }
 204             boolean releasedChild = false;
 205             ArrayList<NotificationData.Entry> children = new ArrayList<>(group.children.values());
 206             int size = children.size();
 207             for (int i = 0; i < size; i++) {
 208                 NotificationData.Entry entry = children.get(i);
 209                 if (onlySummaryAlerts(entry) && entry.row.isHeadsUp()) {
 210                     releasedChild = true;
 211                     mHeadsUpManager.releaseImmediately(entry.key);
 212                 }
 213             }
 214             if (isolatedChild != null && onlySummaryAlerts(isolatedChild)
 215                     && isolatedChild.row.isHeadsUp()) {
 216                 releasedChild = true;
 217                 mHeadsUpManager.releaseImmediately(isolatedChild.key);
 218             }
 219             if (releasedChild && !mHeadsUpManager.isHeadsUp(group.summary.key)) {
 220                 boolean notifyImmediately = (numChildren - numPendingChildren) > 1;
 221                 if (notifyImmediately) {
 222                     mHeadsUpManager.showNotification(group.summary);
 223                 } else {
 224                     group.hunSummaryOnNextAddition = true;
 225                 }
 226                 group.lastHeadsUpTransfer = 0;
 227             }
 228         }
 229     }
 230
 231     private int getPendingChildrenNotAlerting(NotificationGroup group) {
 232         if (mPendingNotifications == null) {
 233             return 0;
 234         }
 235         int number = 0;
 236         String groupKey = getGroupKey(group.summary.notification);
 237         Collection<NotificationData.Entry> values = mPendingNotifications.values();
 238         for (NotificationData.Entry entry : values) {
 239             if (!isGroupChild(entry.notification)) {
 240                 continue;
 241             }
 242             if (!Objects.equals(getGroupKey(entry.notification), groupKey)) {
 243                 continue;
 244             }
 245             if (group.children.containsKey(entry.key)) {
 246                 continue;
 247             }
 248             if (onlySummaryAlerts(entry)) {
 249                 number++;
 250             }
 251         }
 252         return number;
 253     }
 254
 255     private void onEntryBecomingChild(NotificationData.Entry entry) {
 256         if (entry.row.isHeadsUp()) {
 257             onHeadsUpStateChanged(entry, true);
 258         }
 259     }
 260
 261     private void updateSuppression(NotificationGroup group) {
 262         if (group == null) {
 263             return;
 264         }
 265         boolean prevSuppressed = group.suppressed;
 266         group.suppressed = group.summary != null && !group.expanded
 267                 && (group.children.size() == 1
 268                 || (group.children.size() == 0
 269                         && group.summary.notification.getNotification().isGroupSummary()
 270                         && hasIsolatedChildren(group)));
 271         if (prevSuppressed != group.suppressed) {
 272             if (group.suppressed) {
 273                 handleSuppressedSummaryHeadsUpped(group.summary);
 274             }
 275             if (!mIsUpdatingUnchangedGroup && mListener != null) {
 276                 mListener.onGroupsChanged();
 277             }
 278         }
 279     }
 280
 281     private boolean hasIsolatedChildren(NotificationGroup group) {
 282         return getNumberOfIsolatedChildren(group.summary.notification.getGroupKey()) != 0;
 283     }
 284
 285     private int getNumberOfIsolatedChildren(String groupKey) {
 286         int count = 0;
 287         for (StatusBarNotification sbn : mIsolatedEntries.values()) {
 288             if (sbn.getGroupKey().equals(groupKey) && isIsolated(sbn)) {
 289                 count++;
 290             }
 291         }
 292         return count;
 293     }
 294
 295     private NotificationData.Entry getIsolatedChild(String groupKey) {
 296         for (StatusBarNotification sbn : mIsolatedEntries.values()) {
 297             if (sbn.getGroupKey().equals(groupKey) && isIsolated(sbn)) {
 298                 return mGroupMap.get(sbn.getKey()).summary;
 299             }
 300         }
 301         return null;
 302     }
 303
 304     public void onEntryUpdated(NotificationData.Entry entry,
 305             StatusBarNotification oldNotification) {
 306         String oldKey = oldNotification.getGroupKey();
 307         String newKey = entry.notification.getGroupKey();
 308         boolean groupKeysChanged = !oldKey.equals(newKey);
 309         boolean wasGroupChild = isGroupChild(oldNotification);
 310         boolean isGroupChild = isGroupChild(entry.notification);
 311         mIsUpdatingUnchangedGroup = !groupKeysChanged && wasGroupChild == isGroupChild;
 312         if (mGroupMap.get(getGroupKey(oldNotification)) != null) {
 313             onEntryRemovedInternal(entry, oldNotification);
 314         }
 315         onEntryAdded(entry);
 316         mIsUpdatingUnchangedGroup = false;
 317         if (isIsolated(entry.notification)) {
 318             mIsolatedEntries.put(entry.key, entry.notification);
 319             if (groupKeysChanged) {
 320                 updateSuppression(mGroupMap.get(oldKey));
 321                 updateSuppression(mGroupMap.get(newKey));
 322             }
 323         } else if (!wasGroupChild && isGroupChild) {
 324             onEntryBecomingChild(entry);
 325         }
 326     }
 327
 328     public boolean isSummaryOfSuppressedGroup(StatusBarNotification sbn) {
 329         return isGroupSuppressed(getGroupKey(sbn)) && sbn.getNotification().isGroupSummary();
 330     }
 331
 332     private boolean isOnlyChild(StatusBarNotification sbn) {
 333         return !sbn.getNotification().isGroupSummary()
 334                 && getTotalNumberOfChildren(sbn) == 1;
 335     }
 336
 337     public boolean isOnlyChildInGroup(StatusBarNotification sbn) {
 338         if (!isOnlyChild(sbn)) {
 339             return false;
 340         }
 341         ExpandableNotificationRow logicalGroupSummary = getLogicalGroupSummary(sbn);
 342         return logicalGroupSummary != null
 343                 && !logicalGroupSummary.getStatusBarNotification().equals(sbn);
 344     }
 345
 346     private int getTotalNumberOfChildren(StatusBarNotification sbn) {
 347         int isolatedChildren = getNumberOfIsolatedChildren(sbn.getGroupKey());
 348         NotificationGroup group = mGroupMap.get(sbn.getGroupKey());
 349         int realChildren = group != null ? group.children.size() : 0;
 350         return isolatedChildren + realChildren;
 351     }
 352
 353     private boolean isGroupSuppressed(String groupKey) {
 354         NotificationGroup group = mGroupMap.get(groupKey);
 355         return group != null && group.suppressed;
 356     }
 357
 358     public void setStatusBarState(int newState) {
 359         if (mBarState == newState) {
 360             return;
 361         }
 362         mBarState = newState;
 363         if (mBarState == StatusBarState.KEYGUARD) {
 364             collapseAllGroups();
 365         }
 366     }
 367
 368     public void collapseAllGroups() {
 369         // Because notifications can become isolated when the group becomes suppressed it can
 370         // lead to concurrent modifications while looping. We need to make a copy.
 371         ArrayList<NotificationGroup> groupCopy = new ArrayList<>(mGroupMap.values());
 372         int size = groupCopy.size();
 373         for (int i = 0; i < size; i++) {
 374             NotificationGroup group =  groupCopy.get(i);
 375             if (group.expanded) {
 376                 setGroupExpanded(group, false);
 377             }
 378             updateSuppression(group);
 379         }
 380     }
 381
 382     /**
 383      * @return whether a given notification is a child in a group which has a summary
 384      */
 385     public boolean isChildInGroupWithSummary(StatusBarNotification sbn) {
 386         if (!isGroupChild(sbn)) {
 387             return false;
 388         }
 389         NotificationGroup group = mGroupMap.get(getGroupKey(sbn));
 390         if (group == null || group.summary == null || group.suppressed) {
 391             return false;
 392         }
 393         if (group.children.isEmpty()) {
 394             // If the suppression of a group changes because the last child was removed, this can
 395             // still be called temporarily because the child hasn't been fully removed yet. Let's
 396             // make sure we still return false in that case.
 397             return false;
 398         }
 399         return true;
 400     }
 401
 402     /**
 403      * @return whether a given notification is a summary in a group which has children
 404      */
 405     public boolean isSummaryOfGroup(StatusBarNotification sbn) {
 406         if (!isGroupSummary(sbn)) {
 407             return false;
 408         }
 409         NotificationGroup group = mGroupMap.get(getGroupKey(sbn));
 410         if (group == null) {
 411             return false;
 412         }
 413         return !group.children.isEmpty();
 414     }
 415
 416     /**
 417      * Get the summary of a specified status bar notification. For isolated notification this return
 418      * itself.
 419      */
 420     public ExpandableNotificationRow getGroupSummary(StatusBarNotification sbn) {
 421         return getGroupSummary(getGroupKey(sbn));
 422     }
 423
 424     /**
 425      * Similar to {@link #getGroupSummary(StatusBarNotification)} but doesn't get the visual summary
 426      * but the logical summary, i.e when a child is isolated, it still returns the summary as if
 427      * it wasn't isolated.
 428      */
 429     public ExpandableNotificationRow getLogicalGroupSummary(
 430             StatusBarNotification sbn) {
 431         return getGroupSummary(sbn.getGroupKey());
 432     }
 433
 434     @Nullable
 435     private ExpandableNotificationRow getGroupSummary(String groupKey) {
 436         NotificationGroup group = mGroupMap.get(groupKey);
 437         return group == null ? null
 438                 : group.summary == null ? null
 439                         : group.summary.row;
 440     }
 441
 442     /** @return group expansion state after toggling. */
 443     public boolean toggleGroupExpansion(StatusBarNotification sbn) {
 444         NotificationGroup group = mGroupMap.get(getGroupKey(sbn));
 445         if (group == null) {
 446             return false;
 447         }
 448         setGroupExpanded(group, !group.expanded);
 449         return group.expanded;
 450     }
 451
 452     private boolean isIsolated(StatusBarNotification sbn) {
 453         return mIsolatedEntries.containsKey(sbn.getKey());
 454     }
 455
 456     private boolean isGroupSummary(StatusBarNotification sbn) {
 457         if (isIsolated(sbn)) {
 458             return true;
 459         }
 460         return sbn.getNotification().isGroupSummary();
 461     }
 462
 463     private boolean isGroupChild(StatusBarNotification sbn) {
 464         if (isIsolated(sbn)) {
 465             return false;
 466         }
 467         return sbn.isGroup() && !sbn.getNotification().isGroupSummary();
 468     }
 469
 470     private String getGroupKey(StatusBarNotification sbn) {
 471         if (isIsolated(sbn)) {
 472             return sbn.getKey();
 473         }
 474         return sbn.getGroupKey();
 475     }
 476
 477     @Override
 478     public void onHeadsUpPinnedModeChanged(boolean inPinnedMode) {
 479     }
 480
 481     @Override
 482     public void onHeadsUpPinned(ExpandableNotificationRow headsUp) {
 483     }
 484
 485     @Override
 486     public void onHeadsUpUnPinned(ExpandableNotificationRow headsUp) {
 487     }
 488
 489     @Override
 490     public void onHeadsUpStateChanged(NotificationData.Entry entry, boolean isHeadsUp) {
 491         final StatusBarNotification sbn = entry.notification;
 492         if (entry.row.isHeadsUp()) {
 493             if (shouldIsolate(sbn)) {
 494                 // We will be isolated now, so lets update the groups
 495                 onEntryRemovedInternal(entry, entry.notification);
 496
 497                 mIsolatedEntries.put(sbn.getKey(), sbn);
 498
 499                 onEntryAdded(entry);
 500                 // We also need to update the suppression of the old group, because this call comes
 501                 // even before the groupManager knows about the notification at all.
 502                 // When the notification gets added afterwards it is already isolated and therefore
 503                 // it doesn't lead to an update.
 504                 updateSuppression(mGroupMap.get(entry.notification.getGroupKey()));
 505                 mListener.onGroupsChanged();
 506             } else {
 507                 handleSuppressedSummaryHeadsUpped(entry);
 508             }
 509         } else {
 510             if (mIsolatedEntries.containsKey(sbn.getKey())) {
 511                 // not isolated anymore, we need to update the groups
 512                 onEntryRemovedInternal(entry, entry.notification);
 513                 mIsolatedEntries.remove(sbn.getKey());
 514                 onEntryAdded(entry);
 515                 mListener.onGroupsChanged();
 516             }
 517         }
 518     }
 519
 520     private void handleSuppressedSummaryHeadsUpped(NotificationData.Entry entry) {
 521         StatusBarNotification sbn = entry.notification;
 522         if (!isGroupSuppressed(sbn.getGroupKey())
 523                 || !sbn.getNotification().isGroupSummary()
 524                 || !entry.row.isHeadsUp()) {
 525             return;
 526         }
 527
 528         // The parent of a suppressed group got huned, lets hun the child!
 529         NotificationGroup notificationGroup = mGroupMap.get(sbn.getGroupKey());
 530
 531         if (pendingInflationsWillAddChildren(notificationGroup)) {
 532             // New children will actually be added to this group, let's not transfer the heads
 533             // up
 534             return;
 535         }
 536
 537         if (notificationGroup != null) {
 538             Iterator<NotificationData.Entry> iterator
 539                     = notificationGroup.children.values().iterator();
 540             NotificationData.Entry child = iterator.hasNext() ? iterator.next() : null;
 541             if (child == null) {
 542                 child = getIsolatedChild(sbn.getGroupKey());
 543             }
 544             if (child != null) {
 545                 if (child.row.keepInParent() || child.row.isRemoved() || child.row.isDismissed()) {
 546                     // the notification is actually already removed, no need to do heads-up on it.
 547                     return;
 548                 }
 549                 if (mHeadsUpManager.isHeadsUp(child.key)) {
 550                     mHeadsUpManager.updateNotification(child, true);
 551                 } else {
 552                     if (onlySummaryAlerts(entry)) {
 553                         notificationGroup.lastHeadsUpTransfer = SystemClock.elapsedRealtime();
 554                     }
 555                     mHeadsUpManager.showNotification(child);
 556                 }
 557             }
 558         }
 559         mHeadsUpManager.releaseImmediately(entry.key);
 560     }
 561
 562     private boolean onlySummaryAlerts(NotificationData.Entry entry) {
 563         return entry.notification.getNotification().getGroupAlertBehavior()
 564                 == Notification.GROUP_ALERT_SUMMARY;
 565     }
 566
 567     /**
 568      * Check if the pending inflations will add children to this group.
 569      * @param group The group to check.
 570      */
 571     private boolean pendingInflationsWillAddChildren(NotificationGroup group) {
 572         if (mPendingNotifications == null) {
 573             return false;
 574         }
 575         Collection<NotificationData.Entry> values = mPendingNotifications.values();
 576         String groupKey = getGroupKey(group.summary.notification);
 577         for (NotificationData.Entry entry : values) {
 578             if (!isGroupChild(entry.notification)) {
 579                 continue;
 580             }
 581             if (!Objects.equals(getGroupKey(entry.notification), groupKey)) {
 582                 continue;
 583             }
 584             if (!group.children.containsKey(entry.key)) {
 585                 return true;
 586             }
 587         }
 588         return false;
 589     }
 590
 591     private boolean shouldIsolate(StatusBarNotification sbn) {
 592         NotificationGroup notificationGroup = mGroupMap.get(sbn.getGroupKey());
 593         return (sbn.isGroup() && !sbn.getNotification().isGroupSummary())
 594                 && (sbn.getNotification().fullScreenIntent != null
 595                         || notificationGroup == null
 596                         || !notificationGroup.expanded
 597                         || isGroupNotFullyVisible(notificationGroup));
 598     }
 599
 600     private boolean isGroupNotFullyVisible(NotificationGroup notificationGroup) {
 601         return notificationGroup.summary == null
 602                 || notificationGroup.summary.row.getClipTopAmount() > 0
 603                 || notificationGroup.summary.row.getTranslationY() < 0;
 604     }
 605
 606     public void setHeadsUpManager(HeadsUpManager headsUpManager) {
 607         mHeadsUpManager = headsUpManager;
 608     }
 609
 610     public void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
 611         pw.println("GroupManager state:");
 612         pw.println("  number of groups: " +  mGroupMap.size());
 613         for (Map.Entry<String, NotificationGroup>  entry : mGroupMap.entrySet()) {
 614             pw.println("\n    key: " + entry.getKey()); pw.println(entry.getValue());
 615         }
 616         pw.println("\n    isolated entries: " +  mIsolatedEntries.size());
 617         for (Map.Entry<String, StatusBarNotification> entry : mIsolatedEntries.entrySet()) {
 618             pw.print("      "); pw.print(entry.getKey());
 619             pw.print(", "); pw.println(entry.getValue());
 620         }
 621     }
 622
 623     public void setPendingEntries(HashMap<String, NotificationData.Entry> pendingNotifications) {
 624         mPendingNotifications = pendingNotifications;
 625     }
 626
 627     public static class NotificationGroup {
 628         public final HashMap<String, NotificationData.Entry> children = new HashMap<>();
 629         public NotificationData.Entry summary;
 630         public boolean expanded;
 631         /**
 632          * Is this notification group suppressed, i.e its summary is hidden
 633          */
 634         public boolean suppressed;
 635         /**
 636          * The time when the last heads transfer from group to child happened, while the summary
 637          * has the flags to heads up on its own.
 638          */
 639         public long lastHeadsUpTransfer;
 640         public boolean hunSummaryOnNextAddition;
 641
 642         @Override
 643         public String toString() {
 644             String result = "    summary:\n      "
 645                     + (summary != null ? summary.notification : "null")
 646                     + (summary != null && summary.getDebugThrowable() != null
 647                             ? Log.getStackTraceString(summary.getDebugThrowable())
 648                             : "");
 649             result += "\n    children size: " + children.size();
 650             for (NotificationData.Entry child : children.values()) {
 651                 result += "\n      " + child.notification
 652                 + (child.getDebugThrowable() != null
 653                         ? Log.getStackTraceString(child.getDebugThrowable())
 654                         : "");
 655             }
 656             return result;
 657         }
 658     }
 659
 660     public interface OnGroupChangeListener {
 661         /**
 662          * The expansion of a group has changed.
 663          *
 664          * @param changedRow the row for which the expansion has changed, which is also the summary
 665          * @param expanded a boolean indicating the new expanded state
 666          */
 667         void onGroupExpansionChanged(ExpandableNotificationRow changedRow, boolean expanded);
 668
 669         /**
 670          * A group of children just received a summary notification and should therefore become
 671          * children of it.
 672          *
 673          * @param group the group created
 674          */
 675         void onGroupCreatedFromChildren(NotificationGroup group);
 676
 677         /**
 678          * The groups have changed. This can happen if the isolation of a child has changes or if a
 679          * group became suppressed / unsuppressed
 680          */
 681         void onGroupsChanged();
 682     }
 683 }