Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Let auto summaries inherit more flags from children

Browse Source 
Test: GroupHelperTest
Test: NotificationManagerServiceTest
Test: NotificationRecordExtractorDataTest
Test: manually testing with Notify
Fixes: 238564589
Change-Id: Ibe4deae46eb0f583aa8e397ebb02e8c5e12800a8
This commit is contained in:
Julia Reynolds
2023-04-07 12:03:18 -04:00
parent c2bf4faef4
commit 93b8d2daf6
5 changed files with 650 additions and 394 deletions
Download Patch File Download Diff File Expand all files Collapse all files

243
services/core/java/com/android/server/notification/GroupHelper.java
View File

@@ -15,44 +15,53 @@
*/
package com.android.server.notification;
import static android.app.Notification.FLAG_AUTOGROUP_SUMMARY;
import static android.app.Notification.FLAG_AUTO_CANCEL;
import static android.app.Notification.FLAG_GROUP_SUMMARY;
import static android.app.Notification.FLAG_LOCAL_ONLY;
import static android.app.Notification.FLAG_NO_CLEAR;
import static android.app.Notification.FLAG_ONGOING_EVENT;
import android.annotation.NonNull;
import android.service.notification.StatusBarNotification;
import android.util.ArrayMap;
import android.util.ArraySet;
import android.util.Log;
import android.util.Slog;
import com.android.internal.annotations.GuardedBy;
import com.android.internal.annotations.VisibleForTesting;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
/**
* NotificationManagerService helper for auto-grouping notifications.
*/
public class GroupHelper {
private static final String TAG = "GroupHelper";
private static final boolean DEBUG = Log.isLoggable(TAG, Log.DEBUG);
protected static final String AUTOGROUP_KEY = "ranker_group";
// Flags that all autogroup summaries have
protected static final int BASE_FLAGS =
FLAG_AUTOGROUP_SUMMARY | FLAG_GROUP_SUMMARY | FLAG_LOCAL_ONLY;
// Flag that autogroup summaries inherits if all children have the flag
private static final int ALL_CHILDREN_FLAG = FLAG_AUTO_CANCEL;
// Flags that autogroup summaries inherits if any child has them
private static final int ANY_CHILDREN_FLAGS = FLAG_ONGOING_EVENT | FLAG_NO_CLEAR;
private final Callback mCallback;
private final int mAutoGroupAtCount;
// count the number of ongoing notifications per group
// userId|packageName -> (set of ongoing notifications that aren't in an app group)
final ArrayMap<String, ArraySet<String>>
mOngoingGroupCount = new ArrayMap<>();
// Map of user : <Map of package : notification keys>. Only contains notifications that are not
// grouped by the app (aka no group or sort key).
Map<Integer, Map<String, LinkedHashSet<String>>> mUngroupedNotifications = new HashMap<>();
// Only contains notifications that are not explicitly grouped by the app (aka no group or
// sort key).
// userId|packageName -> (keys of notifications that aren't in an explicit app group -> flags)
@GuardedBy("mUngroupedNotifications")
private final ArrayMap<String, ArrayMap<String, Integer>> mUngroupedNotifications
= new ArrayMap<>();
public GroupHelper(int autoGroupAtCount, Callback callback) {
mAutoGroupAtCount = autoGroupAtCount;
mCallback = callback;
mCallback = callback;
}
private String generatePackageKey(int userId, String pkg) {
@@ -60,69 +69,30 @@ public class GroupHelper {
}
@VisibleForTesting
protected int getOngoingGroupCount(int userId, String pkg) {
String key = generatePackageKey(userId, pkg);
return mOngoingGroupCount.getOrDefault(key, new ArraySet<>(0)).size();
@GuardedBy("mUngroupedNotifications")
protected int getAutogroupSummaryFlags(@NonNull final ArrayMap<String, Integer> children) {
boolean allChildrenHasFlag = children.size() > 0;
int anyChildFlagSet = 0;
for (int i = 0; i < children.size(); i++) {
if (!hasAnyFlag(children.valueAt(i), ALL_CHILDREN_FLAG)) {
allChildrenHasFlag = false;
}
if (hasAnyFlag(children.valueAt(i), ANY_CHILDREN_FLAGS)) {
anyChildFlagSet |= (children.valueAt(i) & ANY_CHILDREN_FLAGS);
}
}
return BASE_FLAGS | (allChildrenHasFlag ? ALL_CHILDREN_FLAG : 0) | anyChildFlagSet;
}
private void updateOngoingGroupCount(StatusBarNotification sbn, boolean add) {
if (sbn.getNotification().isGroupSummary()) {
return;
}
String key = generatePackageKey(sbn.getUserId(), sbn.getPackageName());
ArraySet<String> notifications = mOngoingGroupCount.getOrDefault(key, new ArraySet<>(0));
if (add) {
notifications.add(sbn.getKey());
mOngoingGroupCount.put(key, notifications);
} else {
notifications.remove(sbn.getKey());
// we don't need to put it back if it is default
}
boolean needsOngoingFlag = notifications.size() > 0;
mCallback.updateAutogroupSummary(sbn.getUserId(), sbn.getPackageName(), needsOngoingFlag);
}
public void onNotificationUpdated(StatusBarNotification childSbn) {
updateOngoingGroupCount(childSbn, childSbn.isOngoing() && !childSbn.isAppGroup());
private boolean hasAnyFlag(int flags, int mask) {
return (flags & mask) != 0;
}
public void onNotificationPosted(StatusBarNotification sbn, boolean autogroupSummaryExists) {
try {
updateOngoingGroupCount(sbn, sbn.isOngoing() && !sbn.isAppGroup());
List<String> notificationsToGroup = new ArrayList<>();
if (!sbn.isAppGroup()) {
// Not grouped by the app, add to the list of notifications for the app;
// send grouping update if app exceeds the autogrouping limit.
synchronized (mUngroupedNotifications) {
Map<String, LinkedHashSet<String>> ungroupedNotificationsByUser
= mUngroupedNotifications.get(sbn.getUserId());
if (ungroupedNotificationsByUser == null) {
ungroupedNotificationsByUser = new HashMap<>();
}
mUngroupedNotifications.put(sbn.getUserId(), ungroupedNotificationsByUser);
LinkedHashSet<String> notificationsForPackage
= ungroupedNotificationsByUser.get(sbn.getPackageName());
if (notificationsForPackage == null) {
notificationsForPackage = new LinkedHashSet<>();
}
notificationsForPackage.add(sbn.getKey());
ungroupedNotificationsByUser.put(sbn.getPackageName(), notificationsForPackage);
if (notificationsForPackage.size() >= mAutoGroupAtCount
|| autogroupSummaryExists) {
notificationsToGroup.addAll(notificationsForPackage);
}
}
if (notificationsToGroup.size() > 0) {
adjustAutogroupingSummary(sbn.getUserId(), sbn.getPackageName(),
notificationsToGroup.get(0), true);
adjustNotificationBundling(notificationsToGroup, true);
}
maybeGroup(sbn, autogroupSummaryExists);
} else {
// Grouped, but not by us. Send updates to un-autogroup, if we grouped it.
maybeUngroup(sbn, false, sbn.getUserId());
}
@@ -133,7 +103,6 @@ public class GroupHelper {
public void onNotificationRemoved(StatusBarNotification sbn) {
try {
updateOngoingGroupCount(sbn, false);
maybeUngroup(sbn, true, sbn.getUserId());
} catch (Exception e) {
Slog.e(TAG, "Error processing canceled notification", e);
@@ -141,70 +110,114 @@ public class GroupHelper {
}
/**
* Un-autogroups notifications that are now grouped by the app.
* A non-app grouped notification has been added or updated
* Evaluate if:
* (a) an existing autogroup summary needs updated flags
* (b) a new autogroup summary needs to be added with correct flags
* (c) other non-app grouped children need to be moved to the autogroup
*
* And stores the list of upgrouped notifications & their flags
*/
private void maybeGroup(StatusBarNotification sbn, boolean autogroupSummaryExists) {
int flags = 0;
List<String> notificationsToGroup = new ArrayList<>();
synchronized (mUngroupedNotifications) {
String key = generatePackageKey(sbn.getUserId(), sbn.getPackageName());
final ArrayMap<String, Integer> children =
mUngroupedNotifications.getOrDefault(key, new ArrayMap<>());
children.put(sbn.getKey(), sbn.getNotification().flags);
mUngroupedNotifications.put(key, children);
if (children.size() >= mAutoGroupAtCount || autogroupSummaryExists) {
flags = getAutogroupSummaryFlags(children);
notificationsToGroup.addAll(children.keySet());
}
}
if (notificationsToGroup.size() > 0) {
if (autogroupSummaryExists) {
mCallback.updateAutogroupSummary(sbn.getUserId(), sbn.getPackageName(), flags);
} else {
mCallback.addAutoGroupSummary(
sbn.getUserId(), sbn.getPackageName(), sbn.getKey(), flags);
}
for (String key : notificationsToGroup) {
mCallback.addAutoGroup(key);
}
}
}
/**
* A notification was added that's app grouped, or a notification was removed.
* Evaluate whether:
* (a) an existing autogroup summary needs updated flags
* (b) if we need to remove our autogroup overlay for this notification
* (c) we need to remove the autogroup summary
*
* And updates the internal state of un-app-grouped notifications and their flags
*/
private void maybeUngroup(StatusBarNotification sbn, boolean notificationGone, int userId) {
List<String> notificationsToUnAutogroup = new ArrayList<>();
boolean removeSummary = false;
int summaryFlags = 0;
boolean updateSummaryFlags = false;
boolean removeAutogroupOverlay = false;
synchronized (mUngroupedNotifications) {
Map<String, LinkedHashSet<String>> ungroupedNotificationsByUser
= mUngroupedNotifications.get(sbn.getUserId());
if (ungroupedNotificationsByUser == null || ungroupedNotificationsByUser.size() == 0) {
String key = generatePackageKey(sbn.getUserId(), sbn.getPackageName());
final ArrayMap<String, Integer> children =
mUngroupedNotifications.getOrDefault(key, new ArrayMap<>());
if (children.size() == 0) {
return;
}
LinkedHashSet<String> notificationsForPackage
= ungroupedNotificationsByUser.get(sbn.getPackageName());
if (notificationsForPackage == null || notificationsForPackage.size() == 0) {
return;
}
if (notificationsForPackage.remove(sbn.getKey())) {
if (!notificationGone) {
// Add the current notification to the ungrouping list if it still exists.
notificationsToUnAutogroup.add(sbn.getKey());
// if this notif was autogrouped and now isn't
if (children.containsKey(sbn.getKey())) {
// if this notification was contributing flags that aren't covered by other
// children to the summary, reevaluate flags for the summary
int flags = children.remove(sbn.getKey());
// this
if (hasAnyFlag(flags, ANY_CHILDREN_FLAGS)) {
updateSummaryFlags = true;
summaryFlags = getAutogroupSummaryFlags(children);
}
// if this notification still exists and has an autogroup overlay, but is now
// grouped by the app, clear the overlay
if (!notificationGone && sbn.getOverrideGroupKey() != null) {
removeAutogroupOverlay = true;
}
// If there are no more children left to autogroup, remove the summary
if (children.size() == 0) {
removeSummary = true;
}
}
// If the status change of this notification has brought the number of loose
// notifications to zero, remove the summary and un-autogroup.
if (notificationsForPackage.size() == 0) {
ungroupedNotificationsByUser.remove(sbn.getPackageName());
removeSummary = true;
}
}
if (removeSummary) {
adjustAutogroupingSummary(userId, sbn.getPackageName(), null, false);
}
if (notificationsToUnAutogroup.size() > 0) {
adjustNotificationBundling(notificationsToUnAutogroup, false);
}
}
private void adjustAutogroupingSummary(int userId, String packageName, String triggeringKey,
boolean summaryNeeded) {
if (summaryNeeded) {
mCallback.addAutoGroupSummary(userId, packageName, triggeringKey,
getOngoingGroupCount(userId, packageName) > 0);
mCallback.removeAutoGroupSummary(userId, sbn.getPackageName());
} else {
mCallback.removeAutoGroupSummary(userId, packageName);
if (updateSummaryFlags) {
mCallback.updateAutogroupSummary(userId, sbn.getPackageName(), summaryFlags);
}
}
if (removeAutogroupOverlay) {
mCallback.removeAutoGroup(sbn.getKey());
}
}
private void adjustNotificationBundling(List<String> keys, boolean group) {
for (String key : keys) {
if (DEBUG) Log.i(TAG, "Sending grouping adjustment for: " + key + " group? " + group);
if (group) {
mCallback.addAutoGroup(key);
} else {
mCallback.removeAutoGroup(key);
}
@VisibleForTesting
int getNotGroupedByAppCount(int userId, String pkg) {
synchronized (mUngroupedNotifications) {
String key = generatePackageKey(userId, pkg);
final ArrayMap<String, Integer> children =
mUngroupedNotifications.getOrDefault(key, new ArrayMap<>());
return children.size();
}
}
protected interface Callback {
void addAutoGroup(String key);
void removeAutoGroup(String key);
void addAutoGroupSummary(int userId, String pkg, String triggeringKey,
boolean needsOngoingFlag);
void addAutoGroupSummary(int userId, String pkg, String triggeringKey, int flags);
void removeAutoGroupSummary(int user, String pkg);
void updateAutogroupSummary(int userId, String pkg, boolean needsOngoingFlag);
void updateAutogroupSummary(int userId, String pkg, int flags);
}
}

74
services/core/java/com/android/server/notification/NotificationManagerService.java
View File

@@ -319,6 +319,7 @@ import com.android.server.pm.PackageManagerService;
import com.android.server.pm.UserManagerInternal;
import com.android.server.pm.permission.PermissionManagerServiceInternal;
import com.android.server.policy.PermissionPolicyInternal;
import com.android.server.powerstats.StatsPullAtomCallbackImpl;
import com.android.server.statusbar.StatusBarManagerInternal;
import com.android.server.uri.UriGrantsManagerInternal;
import com.android.server.utils.Slogf;
@@ -902,11 +903,11 @@ public class NotificationManagerService extends SystemService {
* has the same flag. It will delete the flag otherwise
* @param userId user id of the autogroup summary
* @param pkg package of the autogroup summary
* @param needsOngoingFlag true if the group has at least one ongoing notification
* @param flags the new flags for this summary
* @param isAppForeground true if the app is currently in the foreground.
*/
@GuardedBy("mNotificationLock")
protected void updateAutobundledSummaryFlags(int userId, String pkg, boolean needsOngoingFlag,
protected void updateAutobundledSummaryFlags(int userId, String pkg, int flags,
boolean isAppForeground) {
ArrayMap<String, String> summaries = mAutobundledSummaries.get(userId);
if (summaries == null) {
@@ -921,13 +922,8 @@ public class NotificationManagerService extends SystemService {
return;
}
int oldFlags = summary.getSbn().getNotification().flags;
if (needsOngoingFlag) {
summary.getSbn().getNotification().flags |= FLAG_ONGOING_EVENT;
} else {
summary.getSbn().getNotification().flags &= ~FLAG_ONGOING_EVENT;
}
if (summary.getSbn().getNotification().flags != oldFlags) {
if (oldFlags != flags) {
summary.getSbn().getNotification().flags = flags;
mHandler.post(new EnqueueNotificationRunnable(userId, summary, isAppForeground,
SystemClock.elapsedRealtime()));
}
@@ -2684,9 +2680,14 @@ public class NotificationManagerService extends SystemService {
@Override
public void addAutoGroupSummary(int userId, String pkg, String triggeringKey,
boolean needsOngoingFlag) {
NotificationManagerService.this.addAutoGroupSummary(
userId, pkg, triggeringKey, needsOngoingFlag);
int flags) {
NotificationRecord r = createAutoGroupSummary(userId, pkg, triggeringKey, flags);
if (r != null) {
final boolean isAppForeground =
mActivityManager.getPackageImportance(pkg) == IMPORTANCE_FOREGROUND;
mHandler.post(new EnqueueNotificationRunnable(userId, r, isAppForeground,
SystemClock.elapsedRealtime()));
}
}
@Override
@@ -2697,11 +2698,11 @@ public class NotificationManagerService extends SystemService {
}
@Override
public void updateAutogroupSummary(int userId, String pkg, boolean needsOngoingFlag) {
public void updateAutogroupSummary(int userId, String pkg, int flags) {
boolean isAppForeground = pkg != null
&& mActivityManager.getPackageImportance(pkg) == IMPORTANCE_FOREGROUND;
synchronized (mNotificationLock) {
updateAutobundledSummaryFlags(userId, pkg, needsOngoingFlag, isAppForeground);
updateAutobundledSummaryFlags(userId, pkg, flags, isAppForeground);
}
}
});
@@ -5961,19 +5962,6 @@ public class NotificationManagerService extends SystemService {
r.addAdjustment(adjustment);
}
@VisibleForTesting
void addAutoGroupSummary(int userId, String pkg, String triggeringKey,
boolean needsOngoingFlag) {
NotificationRecord r = createAutoGroupSummary(
userId, pkg, triggeringKey, needsOngoingFlag);
if (r != null) {
final boolean isAppForeground =
mActivityManager.getPackageImportance(pkg) == IMPORTANCE_FOREGROUND;
mHandler.post(new EnqueueNotificationRunnable(userId, r, isAppForeground,
SystemClock.elapsedRealtime()));
}
}
// Clears the 'fake' auto-group summary.
@VisibleForTesting
@GuardedBy("mNotificationLock")
@@ -5997,7 +5985,7 @@ public class NotificationManagerService extends SystemService {
// Creates a 'fake' summary for a package that has exceeded the solo-notification limit.
NotificationRecord createAutoGroupSummary(int userId, String pkg, String triggeringKey,
boolean needsOngoingFlag) {
int flagsToSet) {
NotificationRecord summaryRecord = null;
boolean isPermissionFixed = mPermissionHelper.isPermissionFixed(pkg, userId);
synchronized (mNotificationLock) {
@@ -6007,7 +5995,6 @@ public class NotificationManagerService extends SystemService {
// adjustment will post a summary if needed.
return null;
}
NotificationChannel channel = notificationRecord.getChannel();
final StatusBarNotification adjustedSbn = notificationRecord.getSbn();
userId = adjustedSbn.getUser().getIdentifier();
int uid = adjustedSbn.getUid();
@@ -6030,11 +6017,8 @@ public class NotificationManagerService extends SystemService {
.setGroupSummary(true)
.setGroupAlertBehavior(Notification.GROUP_ALERT_CHILDREN)
.setGroup(GroupHelper.AUTOGROUP_KEY)
.setFlag(FLAG_AUTOGROUP_SUMMARY, true)
.setFlag(Notification.FLAG_GROUP_SUMMARY, true)
.setFlag(FLAG_ONGOING_EVENT, needsOngoingFlag)
.setFlag(flagsToSet, true)
.setColor(adjustedSbn.getNotification().color)
.setLocalOnly(true)
.build();
summaryNotification.extras.putAll(extras);
Intent appIntent = getContext().getPackageManager().getLaunchIntentForPackage(pkg);
@@ -6372,6 +6356,7 @@ public class NotificationManagerService extends SystemService {
* The private API only accessible to the system process.
*/
private final NotificationManagerInternal mInternalService = new NotificationManagerInternal() {
@Override
public NotificationChannel getNotificationChannel(String pkg, int uid, String
channelId) {
@@ -7827,18 +7812,17 @@ public class NotificationManagerService extends SystemService {
if (notification.getSmallIcon() != null) {
StatusBarNotification oldSbn = (old != null) ? old.getSbn() : null;
mListeners.notifyPostedLocked(r, old);
if ((oldSbn == null || !Objects.equals(oldSbn.getGroup(), n.getGroup()))
&& !isCritical(r)) {
mHandler.post(() -> {
synchronized (mNotificationLock) {
mGroupHelper.onNotificationPosted(
n, hasAutoGroupSummaryLocked(n));
}
});
} else if (oldSbn != null) {
final NotificationRecord finalRecord = r;
mHandler.post(() ->
mGroupHelper.onNotificationUpdated(finalRecord.getSbn()));
if (oldSbn == null
|| !Objects.equals(oldSbn.getGroup(), n.getGroup())
|| oldSbn.getNotification().flags != n.getNotification().flags) {
if (!isCritical(r)) {
mHandler.post(() -> {
synchronized (mNotificationLock) {
mGroupHelper.onNotificationPosted(
n, hasAutoGroupSummaryLocked(n));
}
});
}
}
} else {
Slog.e(TAG, "Not posting notification without small icon: " + notification);

609
services/tests/uiservicestests/src/com/android/server/notification/GroupHelperTest.java
View File

@@ -15,23 +15,31 @@
*/
package com.android.server.notification;
import static com.android.server.notification.GroupHelper.AUTOGROUP_KEY;
import static android.app.Notification.FLAG_AUTO_CANCEL;
import static android.app.Notification.FLAG_BUBBLE;
import static android.app.Notification.FLAG_CAN_COLORIZE;
import static android.app.Notification.FLAG_FOREGROUND_SERVICE;
import static android.app.Notification.FLAG_NO_CLEAR;
import static android.app.Notification.FLAG_ONGOING_EVENT;
import static com.android.server.notification.GroupHelper.BASE_FLAGS;
import static junit.framework.Assert.assertEquals;
import static junit.framework.Assert.assertNotNull;
import static org.mockito.ArgumentMatchers.anyBoolean;
import static org.mockito.Matchers.anyInt;
import static org.mockito.Matchers.anyString;
import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyZeroInteractions;
import android.annotation.SuppressLint;
import android.app.Notification;
import android.os.UserHandle;
import android.service.notification.StatusBarNotification;
import android.test.suitebuilder.annotation.SmallTest;
import android.util.ArrayMap;
import androidx.test.runner.AndroidJUnit4;
@@ -45,11 +53,10 @@ import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import java.util.ArrayList;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
@SmallTest
@SuppressLint("GuardedBy") // It's ok for this test to access guarded methods from the class.
@RunWith(AndroidJUnit4.class)
public class GroupHelperTest extends UiServiceTestCase {
private @Mock GroupHelper.Callback mCallback;
@@ -82,21 +89,104 @@ public class GroupHelperTest extends UiServiceTestCase {
}
@Test
public void testNoGroup_postingUnderLimit() throws Exception {
public void testGetAutogroupSummaryFlags_noChildren() {
ArrayMap<String, Integer> children = new ArrayMap<>();
assertEquals(BASE_FLAGS, mGroupHelper.getAutogroupSummaryFlags(children));
}
@Test
public void testGetAutogroupSummaryFlags_oneOngoing() {
ArrayMap<String, Integer> children = new ArrayMap<>();
children.put("a", 0);
children.put("b", FLAG_ONGOING_EVENT);
children.put("c", FLAG_BUBBLE);
assertEquals(FLAG_ONGOING_EVENT | BASE_FLAGS,
mGroupHelper.getAutogroupSummaryFlags(children));
}
@Test
public void testGetAutogroupSummaryFlags_oneOngoingNoClear() {
ArrayMap<String, Integer> children = new ArrayMap<>();
children.put("a", 0);
children.put("b", FLAG_ONGOING_EVENT|FLAG_NO_CLEAR);
children.put("c", FLAG_BUBBLE);
assertEquals(FLAG_NO_CLEAR | FLAG_ONGOING_EVENT | BASE_FLAGS,
mGroupHelper.getAutogroupSummaryFlags(children));
}
@Test
public void testGetAutogroupSummaryFlags_oneOngoingBubble() {
ArrayMap<String, Integer> children = new ArrayMap<>();
children.put("a", 0);
children.put("b", FLAG_ONGOING_EVENT | FLAG_BUBBLE);
children.put("c", FLAG_BUBBLE);
assertEquals(FLAG_ONGOING_EVENT | BASE_FLAGS,
mGroupHelper.getAutogroupSummaryFlags(children));
}
@Test
public void testGetAutogroupSummaryFlags_multipleOngoing() {
ArrayMap<String, Integer> children = new ArrayMap<>();
children.put("a", 0);
children.put("b", FLAG_ONGOING_EVENT);
children.put("c", FLAG_BUBBLE);
children.put("d", FLAG_ONGOING_EVENT);
assertEquals(FLAG_ONGOING_EVENT | BASE_FLAGS,
mGroupHelper.getAutogroupSummaryFlags(children));
}
@Test
public void testGetAutogroupSummaryFlags_oneAutoCancel() {
ArrayMap<String, Integer> children = new ArrayMap<>();
children.put("a", 0);
children.put("b", FLAG_AUTO_CANCEL);
children.put("c", FLAG_BUBBLE);
assertEquals(BASE_FLAGS,
mGroupHelper.getAutogroupSummaryFlags(children));
}
@Test
public void testGetAutogroupSummaryFlags_allAutoCancel() {
ArrayMap<String, Integer> children = new ArrayMap<>();
children.put("a", FLAG_AUTO_CANCEL);
children.put("b", FLAG_AUTO_CANCEL | FLAG_CAN_COLORIZE);
children.put("c", FLAG_AUTO_CANCEL);
children.put("d", FLAG_AUTO_CANCEL | FLAG_FOREGROUND_SERVICE);
assertEquals(FLAG_AUTO_CANCEL | BASE_FLAGS,
mGroupHelper.getAutogroupSummaryFlags(children));
}
@Test
public void testGetAutogroupSummaryFlags_allAutoCancelOneOngoing() {
ArrayMap<String, Integer> children = new ArrayMap<>();
children.put("a", FLAG_AUTO_CANCEL);
children.put("b", FLAG_AUTO_CANCEL | FLAG_CAN_COLORIZE);
children.put("c", FLAG_AUTO_CANCEL);
children.put("d", FLAG_AUTO_CANCEL | FLAG_FOREGROUND_SERVICE | FLAG_ONGOING_EVENT);
assertEquals(FLAG_AUTO_CANCEL| FLAG_ONGOING_EVENT | BASE_FLAGS,
mGroupHelper.getAutogroupSummaryFlags(children));
}
@Test
public void testNoGroup_postingUnderLimit() {
final String pkg = "package";
for (int i = 0; i < AUTOGROUP_AT_COUNT - 1; i++) {
mGroupHelper.onNotificationPosted(getSbn(pkg, i, String.valueOf(i), UserHandle.SYSTEM),
false);
}
verify(mCallback, never()).addAutoGroupSummary(
eq(UserHandle.USER_SYSTEM), eq(pkg), anyString(), anyBoolean());
verify(mCallback, never()).addAutoGroup(anyString());
verify(mCallback, never()).removeAutoGroup(anyString());
verify(mCallback, never()).removeAutoGroupSummary(anyInt(), anyString());
verifyZeroInteractions(mCallback);
}
@Test
public void testNoGroup_multiPackage() throws Exception {
public void testNoGroup_multiPackage() {
final String pkg = "package";
final String pkg2 = "package2";
for (int i = 0; i < AUTOGROUP_AT_COUNT - 1; i++) {
@@ -105,31 +195,23 @@ public class GroupHelperTest extends UiServiceTestCase {
}
mGroupHelper.onNotificationPosted(
getSbn(pkg2, AUTOGROUP_AT_COUNT, "four", UserHandle.SYSTEM), false);
verify(mCallback, never()).addAutoGroupSummary(
eq(UserHandle.USER_SYSTEM), eq(pkg), anyString(), anyBoolean());
verify(mCallback, never()).addAutoGroup(anyString());
verify(mCallback, never()).removeAutoGroup(anyString());
verify(mCallback, never()).removeAutoGroupSummary(anyInt(), anyString());
verifyZeroInteractions(mCallback);
}
@Test
public void testNoGroup_multiUser() throws Exception {
public void testNoGroup_multiUser() {
final String pkg = "package";
for (int i = 0; i < AUTOGROUP_AT_COUNT - 1; i++) {
mGroupHelper.onNotificationPosted(getSbn(pkg, i, String.valueOf(i), UserHandle.SYSTEM),
false);
}
mGroupHelper.onNotificationPosted(
getSbn(pkg, AUTOGROUP_AT_COUNT, "four", UserHandle.ALL), false);
verify(mCallback, never()).addAutoGroupSummary(
anyInt(), eq(pkg), anyString(), anyBoolean());
verify(mCallback, never()).addAutoGroup(anyString());
verify(mCallback, never()).removeAutoGroup(anyString());
verify(mCallback, never()).removeAutoGroupSummary(anyInt(), anyString());
getSbn(pkg, AUTOGROUP_AT_COUNT, "four", UserHandle.of(7)), false);
verifyZeroInteractions(mCallback);
}
@Test
public void testNoGroup_someAreGrouped() throws Exception {
public void testNoGroup_someAreGrouped() {
final String pkg = "package";
for (int i = 0; i < AUTOGROUP_AT_COUNT - 1; i++) {
mGroupHelper.onNotificationPosted(
@@ -137,233 +219,344 @@ public class GroupHelperTest extends UiServiceTestCase {
}
mGroupHelper.onNotificationPosted(
getSbn(pkg, AUTOGROUP_AT_COUNT, "four", UserHandle.SYSTEM, "a"), false);
verify(mCallback, never()).addAutoGroupSummary(
eq(UserHandle.USER_SYSTEM), eq(pkg), anyString(), anyBoolean());
verify(mCallback, never()).addAutoGroup(anyString());
verify(mCallback, never()).removeAutoGroup(anyString());
verify(mCallback, never()).removeAutoGroupSummary(anyInt(), anyString());
verifyZeroInteractions(mCallback);
}
@Test
public void testPostingOverLimit() throws Exception {
public void testAddSummary() {
final String pkg = "package";
for (int i = 0; i < AUTOGROUP_AT_COUNT; i++) {
mGroupHelper.onNotificationPosted(
getSbn(pkg, i, String.valueOf(i), UserHandle.SYSTEM), false);
}
verify(mCallback, times(1)).addAutoGroupSummary(anyInt(), eq(pkg), anyString(), eq(false));
verify(mCallback, times(1)).addAutoGroupSummary(
anyInt(), eq(pkg), anyString(), eq(BASE_FLAGS));
verify(mCallback, times(AUTOGROUP_AT_COUNT)).addAutoGroup(anyString());
verify(mCallback, never()).removeAutoGroup(anyString());
verify(mCallback, never()).removeAutoGroupSummary(anyInt(), anyString());
verify(mCallback, never()).updateAutogroupSummary(anyInt(), anyString(), anyInt());
}
@Test
public void testPostingOverLimit_addsOngoingFlag() throws Exception {
public void testAddSummary_oneChildOngoing_summaryOngoing() {
final String pkg = "package";
for (int i = 0; i < AUTOGROUP_AT_COUNT; i++) {
StatusBarNotification sbn = getSbn(pkg, i, String.valueOf(i), UserHandle.SYSTEM);
if (i == 0) {
sbn.getNotification().flags |= Notification.FLAG_ONGOING_EVENT;
sbn.getNotification().flags |= FLAG_ONGOING_EVENT;
}
mGroupHelper.onNotificationPosted(sbn, false);
}
verify(mCallback, times(1)).addAutoGroupSummary(anyInt(), eq(pkg), anyString(), eq(true));
verify(mCallback, times(1)).addAutoGroupSummary(anyInt(), eq(pkg), anyString(),
eq(BASE_FLAGS | FLAG_ONGOING_EVENT));
verify(mCallback, times(AUTOGROUP_AT_COUNT)).addAutoGroup(anyString());
verify(mCallback, never()).removeAutoGroup(anyString());
verify(mCallback, never()).removeAutoGroupSummary(anyInt(), anyString());
verify(mCallback, never()).updateAutogroupSummary(anyInt(), anyString(), anyInt());
}
@Test
public void testAutoGroupCount_addingNoGroupSBN() {
public void testAddSummary_oneChildAutoCancel_summaryNotAutoCancel() {
final String pkg = "package";
ArrayList<StatusBarNotification> notifications = new ArrayList<>();
for (int i = 0; i < AUTOGROUP_AT_COUNT + 1; i++) {
notifications.add(getSbn(pkg, i, String.valueOf(i), UserHandle.SYSTEM));
for (int i = 0; i < AUTOGROUP_AT_COUNT; i++) {
StatusBarNotification sbn = getSbn(pkg, i, String.valueOf(i), UserHandle.SYSTEM);
if (i == 0) {
sbn.getNotification().flags |= FLAG_AUTO_CANCEL;
}
mGroupHelper.onNotificationPosted(sbn, false);
}
for (StatusBarNotification sbn: notifications) {
sbn.getNotification().flags |= Notification.FLAG_ONGOING_EVENT;
sbn.setOverrideGroupKey(AUTOGROUP_KEY);
}
for (StatusBarNotification sbn: notifications) {
mGroupHelper.onNotificationPosted(sbn, true);
}
verify(mCallback, times(AUTOGROUP_AT_COUNT + 1))
.updateAutogroupSummary(anyInt(), anyString(), eq(true));
int userId = UserHandle.SYSTEM.getIdentifier();
assertEquals(mGroupHelper.getOngoingGroupCount(
userId, pkg), AUTOGROUP_AT_COUNT + 1);
verify(mCallback, times(1)).addAutoGroupSummary(
anyInt(), eq(pkg), anyString(), eq(BASE_FLAGS));
verify(mCallback, times(AUTOGROUP_AT_COUNT)).addAutoGroup(anyString());
verify(mCallback, never()).removeAutoGroup(anyString());
verify(mCallback, never()).removeAutoGroupSummary(anyInt(), anyString());
verify(mCallback, never()).updateAutogroupSummary(anyInt(), anyString(), anyInt());
}
@Test
public void testAutoGroupCount_UpdateNotification() {
public void testAddSummary_allChildrenAutoCancel_summaryAutoCancel() {
final String pkg = "package";
ArrayList<StatusBarNotification> notifications = new ArrayList<>();
for (int i = 0; i < AUTOGROUP_AT_COUNT + 1; i++) {
notifications.add(getSbn(pkg, i, String.valueOf(i), UserHandle.SYSTEM));
for (int i = 0; i < AUTOGROUP_AT_COUNT; i++) {
StatusBarNotification sbn = getSbn(pkg, i, String.valueOf(i), UserHandle.SYSTEM);
sbn.getNotification().flags |= FLAG_AUTO_CANCEL;
mGroupHelper.onNotificationPosted(sbn, false);
}
for (StatusBarNotification sbn: notifications) {
sbn.getNotification().flags |= Notification.FLAG_ONGOING_EVENT;
sbn.setOverrideGroupKey(AUTOGROUP_KEY);
}
for (StatusBarNotification sbn: notifications) {
mGroupHelper.onNotificationPosted(sbn, true);
}
notifications.get(0).getNotification().flags &= ~Notification.FLAG_ONGOING_EVENT;
mGroupHelper.onNotificationUpdated(notifications.get(0));
verify(mCallback, times(AUTOGROUP_AT_COUNT + 2))
.updateAutogroupSummary(anyInt(), anyString(), eq(true));
int userId = UserHandle.SYSTEM.getIdentifier();
assertEquals(mGroupHelper.getOngoingGroupCount(
userId, pkg), AUTOGROUP_AT_COUNT);
verify(mCallback, times(1)).addAutoGroupSummary(anyInt(), eq(pkg), anyString(),
eq(BASE_FLAGS | FLAG_AUTO_CANCEL));
verify(mCallback, times(AUTOGROUP_AT_COUNT)).addAutoGroup(anyString());
verify(mCallback, never()).removeAutoGroup(anyString());
verify(mCallback, never()).removeAutoGroupSummary(anyInt(), anyString());
verify(mCallback, never()).updateAutogroupSummary(anyInt(), anyString(), anyInt());
}
@Test
public void testAutoGroupCount_UpdateNotificationAfterChanges() {
public void testAddSummary_summaryAutoCancelNoClear() {
final String pkg = "package";
ArrayList<StatusBarNotification> notifications = new ArrayList<>();
for (int i = 0; i < AUTOGROUP_AT_COUNT + 1; i++) {
notifications.add(getSbn(pkg, i, String.valueOf(i), UserHandle.SYSTEM));
for (int i = 0; i < AUTOGROUP_AT_COUNT; i++) {
StatusBarNotification sbn = getSbn(pkg, i, String.valueOf(i), UserHandle.SYSTEM);
sbn.getNotification().flags |= FLAG_AUTO_CANCEL;
if (i == 0) {
sbn.getNotification().flags |= FLAG_NO_CLEAR;
}
mGroupHelper.onNotificationPosted(sbn, false);
}
for (StatusBarNotification sbn: notifications) {
sbn.getNotification().flags |= Notification.FLAG_ONGOING_EVENT;
sbn.setOverrideGroupKey(AUTOGROUP_KEY);
}
for (StatusBarNotification sbn: notifications) {
mGroupHelper.onNotificationPosted(sbn, true);
}
notifications.get(0).getNotification().flags &= ~Notification.FLAG_ONGOING_EVENT;
mGroupHelper.onNotificationUpdated(notifications.get(0));
notifications.get(0).getNotification().flags |= Notification.FLAG_ONGOING_EVENT;
mGroupHelper.onNotificationUpdated(notifications.get(0));
verify(mCallback, times(AUTOGROUP_AT_COUNT + 3))
.updateAutogroupSummary(anyInt(), anyString(), eq(true));
int userId = UserHandle.SYSTEM.getIdentifier();
assertEquals(mGroupHelper.getOngoingGroupCount(
userId, pkg), AUTOGROUP_AT_COUNT + 1);
verify(mCallback, times(1)).addAutoGroupSummary(anyInt(), eq(pkg), anyString(),
eq(BASE_FLAGS | FLAG_AUTO_CANCEL | FLAG_NO_CLEAR));
verify(mCallback, times(AUTOGROUP_AT_COUNT)).addAutoGroup(anyString());
verify(mCallback, never()).removeAutoGroup(anyString());
verify(mCallback, never()).removeAutoGroupSummary(anyInt(), anyString());
verify(mCallback, never()).updateAutogroupSummary(anyInt(), anyString(), anyInt());
}
@Test
public void testAutoGroupCount_RemoveNotification() {
public void testAutoGrouped_allOngoing_updateChildNotOngoing() {
final String pkg = "package";
// Post AUTOGROUP_AT_COUNT ongoing notifications
ArrayList<StatusBarNotification> notifications = new ArrayList<>();
for (int i = 0; i < AUTOGROUP_AT_COUNT + 1; i++) {
notifications.add(getSbn(pkg, i, String.valueOf(i), UserHandle.SYSTEM));
for (int i = 0; i < AUTOGROUP_AT_COUNT; i++) {
StatusBarNotification sbn = getSbn(pkg, i, String.valueOf(i), UserHandle.SYSTEM);
sbn.getNotification().flags |= FLAG_ONGOING_EVENT;
notifications.add(sbn);
}
for (StatusBarNotification sbn: notifications) {
sbn.getNotification().flags |= Notification.FLAG_ONGOING_EVENT;
sbn.setOverrideGroupKey(AUTOGROUP_KEY);
mGroupHelper.onNotificationPosted(sbn, false);
}
// One notification is no longer ongoing
notifications.get(0).getNotification().flags &= ~FLAG_ONGOING_EVENT;
mGroupHelper.onNotificationPosted(notifications.get(0), true);
// Summary should keep FLAG_ONGOING_EVENT if any child has it
verify(mCallback).updateAutogroupSummary(
anyInt(), anyString(), eq(BASE_FLAGS | FLAG_ONGOING_EVENT));
}
@Test
public void testAutoGrouped_singleOngoing_removeOngoingChild() {
final String pkg = "package";
// Post AUTOGROUP_AT_COUNT ongoing notifications
ArrayList<StatusBarNotification> notifications = new ArrayList<>();
for (int i = 0; i < AUTOGROUP_AT_COUNT; i++) {
StatusBarNotification sbn = getSbn(pkg, i, String.valueOf(i), UserHandle.SYSTEM);
if (i == 0) {
sbn.getNotification().flags |= FLAG_ONGOING_EVENT;
}
notifications.add(sbn);
}
for (StatusBarNotification sbn: notifications) {
mGroupHelper.onNotificationPosted(sbn, true);
mGroupHelper.onNotificationPosted(sbn, false);
}
// remove ongoing
mGroupHelper.onNotificationRemoved(notifications.get(0));
// Summary is no longer ongoing
verify(mCallback).updateAutogroupSummary(anyInt(), anyString(), eq(BASE_FLAGS));
}
@Test
public void testAutoGrouped_noOngoing_updateOngoingChild() {
final String pkg = "package";
// Post AUTOGROUP_AT_COUNT ongoing notifications
ArrayList<StatusBarNotification> notifications = new ArrayList<>();
for (int i = 0; i < AUTOGROUP_AT_COUNT; i++) {
StatusBarNotification sbn = getSbn(pkg, i, String.valueOf(i), UserHandle.SYSTEM);
notifications.add(sbn);
}
for (StatusBarNotification sbn: notifications) {
mGroupHelper.onNotificationPosted(sbn, false);
}
// update to ongoing
notifications.get(0).getNotification().flags |= FLAG_ONGOING_EVENT;
mGroupHelper.onNotificationPosted(notifications.get(0), true);
// Summary is now ongoing
verify(mCallback).updateAutogroupSummary(
anyInt(), anyString(), eq(BASE_FLAGS | FLAG_ONGOING_EVENT));
}
@Test
public void testAutoGrouped_noOngoing_addOngoingChild() {
final String pkg = "package";
// Post AUTOGROUP_AT_COUNT ongoing notifications
ArrayList<StatusBarNotification> notifications = new ArrayList<>();
for (int i = 0; i < AUTOGROUP_AT_COUNT; i++) {
StatusBarNotification sbn = getSbn(pkg, i, String.valueOf(i), UserHandle.SYSTEM);
notifications.add(sbn);
}
for (StatusBarNotification sbn: notifications) {
mGroupHelper.onNotificationPosted(sbn, false);
}
// add ongoing
StatusBarNotification sbn = getSbn(pkg, AUTOGROUP_AT_COUNT + 1, null, UserHandle.SYSTEM);
sbn.getNotification().flags |= FLAG_ONGOING_EVENT;
mGroupHelper.onNotificationPosted(sbn, true);
// Summary is now ongoing
verify(mCallback).updateAutogroupSummary(
anyInt(), anyString(), eq(BASE_FLAGS | FLAG_ONGOING_EVENT));
}
@Test
public void testAutoGrouped_singleOngoing_appGroupOngoingChild() {
final String pkg = "package";
// Post AUTOGROUP_AT_COUNT ongoing notifications
ArrayList<StatusBarNotification> notifications = new ArrayList<>();
for (int i = 0; i < AUTOGROUP_AT_COUNT; i++) {
StatusBarNotification sbn = getSbn(pkg, i, String.valueOf(i), UserHandle.SYSTEM);
if (i == 0) {
sbn.getNotification().flags |= FLAG_ONGOING_EVENT;
}
notifications.add(sbn);
}
for (StatusBarNotification sbn: notifications) {
mGroupHelper.onNotificationPosted(sbn, false);
}
// app group the ongoing child
StatusBarNotification sbn = getSbn(pkg, 0, "0", UserHandle.SYSTEM, "app group now");
mGroupHelper.onNotificationPosted(sbn, true);
// Summary is no longer ongoing
verify(mCallback).updateAutogroupSummary(anyInt(), anyString(), eq(BASE_FLAGS));
}
@Test
public void testAutoGrouped_singleOngoing_removeNonOngoingChild() {
final String pkg = "package";
// Post AUTOGROUP_AT_COUNT ongoing notifications
ArrayList<StatusBarNotification> notifications = new ArrayList<>();
for (int i = 0; i < AUTOGROUP_AT_COUNT; i++) {
StatusBarNotification sbn = getSbn(pkg, i, String.valueOf(i), UserHandle.SYSTEM);
if (i == 0) {
sbn.getNotification().flags |= FLAG_ONGOING_EVENT;
}
notifications.add(sbn);
}
for (StatusBarNotification sbn: notifications) {
mGroupHelper.onNotificationPosted(sbn, false);
}
// remove ongoing
mGroupHelper.onNotificationRemoved(notifications.get(1));
// Summary is still ongoing
verify(mCallback, never()).updateAutogroupSummary(anyInt(), anyString(), anyInt());
}
@Test
public void testAutoGrouped_allAutoCancel_updateChildNotAutoCancel() {
final String pkg = "package";
// Post AUTOGROUP_AT_COUNT ongoing notifications
ArrayList<StatusBarNotification> notifications = new ArrayList<>();
for (int i = 0; i < AUTOGROUP_AT_COUNT; i++) {
StatusBarNotification sbn = getSbn(pkg, i, String.valueOf(i), UserHandle.SYSTEM);
sbn.getNotification().flags |= FLAG_AUTO_CANCEL;
notifications.add(sbn);
}
for (StatusBarNotification sbn: notifications) {
mGroupHelper.onNotificationPosted(sbn, false);
}
// One notification is no longer autocancelable
notifications.get(0).getNotification().flags &= ~FLAG_AUTO_CANCEL;
mGroupHelper.onNotificationPosted(notifications.get(0), true);
// Summary should no longer be autocancelable
verify(mCallback).updateAutogroupSummary(anyInt(), anyString(), eq(BASE_FLAGS));
}
@Test
public void testAutoGrouped_almostAllAutoCancel_updateChildAutoCancel() {
final String pkg = "package";
// Post AUTOGROUP_AT_COUNT ongoing notifications
ArrayList<StatusBarNotification> notifications = new ArrayList<>();
for (int i = 0; i < AUTOGROUP_AT_COUNT; i++) {
StatusBarNotification sbn = getSbn(pkg, i, String.valueOf(i), UserHandle.SYSTEM);
if (i != 0) {
sbn.getNotification().flags |= FLAG_AUTO_CANCEL;
}
notifications.add(sbn);
}
for (StatusBarNotification sbn: notifications) {
mGroupHelper.onNotificationPosted(sbn, false);
}
// Missing notification is now autocancelable
notifications.get(0).getNotification().flags |= FLAG_AUTO_CANCEL;
mGroupHelper.onNotificationPosted(notifications.get(0), true);
// Summary should now autocancelable
verify(mCallback).updateAutogroupSummary(
anyInt(), anyString(), eq(BASE_FLAGS | FLAG_AUTO_CANCEL));
}
@Test
public void testAutoGrouped_allAutoCancel_updateChildAppGrouped() {
final String pkg = "package";
// Post AUTOGROUP_AT_COUNT ongoing notifications
ArrayList<StatusBarNotification> notifications = new ArrayList<>();
for (int i = 0; i < AUTOGROUP_AT_COUNT; i++) {
StatusBarNotification sbn = getSbn(pkg, i, String.valueOf(i), UserHandle.SYSTEM);
sbn.getNotification().flags |= FLAG_AUTO_CANCEL;
notifications.add(sbn);
}
for (StatusBarNotification sbn: notifications) {
mGroupHelper.onNotificationPosted(sbn, false);
}
// One notification is now grouped by app
StatusBarNotification sbn = getSbn(pkg, 0, "0", UserHandle.SYSTEM, "app group now");
mGroupHelper.onNotificationPosted(sbn, true);
// Summary should be still be autocancelable
verify(mCallback, never()).updateAutogroupSummary(anyInt(), anyString(), anyInt());
}
@Test
public void testAutoGrouped_allAutoCancel_removeChild() {
final String pkg = "package";
// Post AUTOGROUP_AT_COUNT ongoing notifications
ArrayList<StatusBarNotification> notifications = new ArrayList<>();
for (int i = 0; i < AUTOGROUP_AT_COUNT; i++) {
StatusBarNotification sbn = getSbn(pkg, i, String.valueOf(i), UserHandle.SYSTEM);
sbn.getNotification().flags |= FLAG_AUTO_CANCEL;
notifications.add(sbn);
}
for (StatusBarNotification sbn: notifications) {
mGroupHelper.onNotificationPosted(sbn, false);
}
mGroupHelper.onNotificationRemoved(notifications.get(0));
verify(mCallback, times(AUTOGROUP_AT_COUNT + 2))
.updateAutogroupSummary(anyInt(), anyString(), eq(true));
int userId = UserHandle.SYSTEM.getIdentifier();
assertEquals(mGroupHelper.getOngoingGroupCount(
userId, pkg), AUTOGROUP_AT_COUNT);
}
@Test
public void testAutoGroupCount_UpdateToNoneOngoingNotification() {
final String pkg = "package";
ArrayList<StatusBarNotification> notifications = new ArrayList<>();
for (int i = 0; i < AUTOGROUP_AT_COUNT + 1; i++) {
notifications.add(getSbn(pkg, i, String.valueOf(i), UserHandle.SYSTEM));
}
for (StatusBarNotification sbn: notifications) {
sbn.setOverrideGroupKey(AUTOGROUP_KEY);
}
for (StatusBarNotification sbn: notifications) {
mGroupHelper.onNotificationPosted(sbn, true);
}
notifications.get(0).getNotification().flags |= Notification.FLAG_ONGOING_EVENT;
mGroupHelper.onNotificationUpdated(notifications.get(0));
verify(mCallback, times(1))
.updateAutogroupSummary(anyInt(), anyString(), eq(true));
int userId = UserHandle.SYSTEM.getIdentifier();
assertEquals(mGroupHelper.getOngoingGroupCount(
userId, pkg), 1);
// Summary should still be autocancelable
verify(mCallback, never()).updateAutogroupSummary(anyInt(), anyString(), anyInt());
}
@Test
public void testAutoGroupCount_AddOneOngoingNotification() {
final String pkg = "package";
ArrayList<StatusBarNotification> notifications = new ArrayList<>();
for (int i = 0; i < AUTOGROUP_AT_COUNT + 1; i++) {
notifications.add(getSbn(pkg, i, String.valueOf(i), UserHandle.SYSTEM));
}
StatusBarNotification sbn = notifications.get(AUTOGROUP_AT_COUNT);
sbn.getNotification().flags |= Notification.FLAG_ONGOING_EVENT;
sbn.setOverrideGroupKey(AUTOGROUP_KEY);
for (StatusBarNotification current: notifications) {
mGroupHelper.onNotificationPosted(current, true);
}
verify(mCallback, times(1))
.updateAutogroupSummary(anyInt(), anyString(), eq(true));
int userId = UserHandle.SYSTEM.getIdentifier();
assertEquals(mGroupHelper.getOngoingGroupCount(
userId, pkg), 1);
}
@Test
public void testAutoGroupCount_UpdateNoneOngoing() {
final String pkg = "package";
ArrayList<StatusBarNotification> notifications = new ArrayList<>();
for (int i = 0; i < AUTOGROUP_AT_COUNT + 1; i++) {
notifications.add(getSbn(pkg, i, String.valueOf(i), UserHandle.SYSTEM));
}
for (StatusBarNotification sbn: notifications) {
sbn.setOverrideGroupKey(AUTOGROUP_KEY);
}
for (StatusBarNotification sbn: notifications) {
mGroupHelper.onNotificationPosted(sbn, true);
}
verify(mCallback, times(0))
.updateAutogroupSummary(anyInt(), anyString(), eq(true));
int userId = UserHandle.SYSTEM.getIdentifier();
assertEquals(mGroupHelper.getOngoingGroupCount(userId, pkg), 0);
}
@Test
public void testDropToZeroRemoveGroup() throws Exception {
public void testDropToZeroRemoveGroup() {
final String pkg = "package";
List<StatusBarNotification> posted = new ArrayList<>();
for (int i = 0; i < AUTOGROUP_AT_COUNT; i++) {
@@ -371,7 +564,8 @@ public class GroupHelperTest extends UiServiceTestCase {
posted.add(sbn);
mGroupHelper.onNotificationPosted(sbn, false);
}
verify(mCallback, times(1)).addAutoGroupSummary(anyInt(), eq(pkg), anyString(), eq(false));
verify(mCallback, times(1)).addAutoGroupSummary(
anyInt(), eq(pkg), anyString(), eq(BASE_FLAGS));
verify(mCallback, times(AUTOGROUP_AT_COUNT)).addAutoGroup(anyString());
verify(mCallback, never()).removeAutoGroup(anyString());
verify(mCallback, never()).removeAutoGroupSummary(anyInt(), anyString());
@@ -390,7 +584,7 @@ public class GroupHelperTest extends UiServiceTestCase {
}
@Test
public void testAppStartsGrouping() throws Exception {
public void testAppStartsGrouping() {
final String pkg = "package";
List<StatusBarNotification> posted = new ArrayList<>();
for (int i = 0; i < AUTOGROUP_AT_COUNT; i++) {
@@ -399,7 +593,7 @@ public class GroupHelperTest extends UiServiceTestCase {
mGroupHelper.onNotificationPosted(sbn, false);
}
verify(mCallback, times(1)).addAutoGroupSummary(
anyInt(), eq(pkg), anyString(), anyBoolean());
anyInt(), eq(pkg), anyString(), eq(BASE_FLAGS));
verify(mCallback, times(AUTOGROUP_AT_COUNT)).addAutoGroup(anyString());
verify(mCallback, never()).removeAutoGroup(anyString());
verify(mCallback, never()).removeAutoGroupSummary(anyInt(), anyString());
@@ -408,9 +602,10 @@ public class GroupHelperTest extends UiServiceTestCase {
for (int i = 0; i < AUTOGROUP_AT_COUNT; i++) {
final StatusBarNotification sbn =
getSbn(pkg, i, String.valueOf(i), UserHandle.SYSTEM, "app group");
mGroupHelper.onNotificationPosted(sbn, false);
sbn.setOverrideGroupKey("autogrouped");
mGroupHelper.onNotificationPosted(sbn, true);
verify(mCallback, times(1)).removeAutoGroup(sbn.getKey());
if (i < AUTOGROUP_AT_COUNT -1) {
if (i < AUTOGROUP_AT_COUNT - 1) {
verify(mCallback, never()).removeAutoGroupSummary(anyInt(), anyString());
}
}
@@ -418,8 +613,7 @@ public class GroupHelperTest extends UiServiceTestCase {
}
@Test
public void testNewNotificationsAddedToAutogroup_ifOriginalNotificationsCanceled()
throws Exception {
public void testNewNotificationsAddedToAutogroup_ifOriginalNotificationsCanceled() {
final String pkg = "package";
List<StatusBarNotification> posted = new ArrayList<>();
for (int i = 0; i < AUTOGROUP_AT_COUNT; i++) {
@@ -427,7 +621,8 @@ public class GroupHelperTest extends UiServiceTestCase {
posted.add(sbn);
mGroupHelper.onNotificationPosted(sbn, false);
}
verify(mCallback, times(1)).addAutoGroupSummary(anyInt(), eq(pkg), anyString(), eq(false));
verify(mCallback, times(1)).addAutoGroupSummary(
anyInt(), eq(pkg), anyString(), eq(BASE_FLAGS));
verify(mCallback, times(AUTOGROUP_AT_COUNT)).addAutoGroup(anyString());
verify(mCallback, never()).removeAutoGroup(anyString());
verify(mCallback, never()).removeAutoGroupSummary(anyInt(), anyString());
@@ -441,10 +636,7 @@ public class GroupHelperTest extends UiServiceTestCase {
Mockito.reset(mCallback);
// only one child remains
Map<String, LinkedHashSet<String>> ungroupedForUser =
mGroupHelper.mUngroupedNotifications.get(UserHandle.USER_SYSTEM);
assertNotNull(ungroupedForUser);
assertEquals(1, ungroupedForUser.get(pkg).size());
assertEquals(1, mGroupHelper.getNotGroupedByAppCount(UserHandle.USER_SYSTEM, pkg));
// Add new notification; it should be autogrouped even though the total count is
// < AUTOGROUP_AT_COUNT
@@ -454,5 +646,8 @@ public class GroupHelperTest extends UiServiceTestCase {
verify(mCallback, times(1)).addAutoGroup(sbn.getKey());
verify(mCallback, never()).removeAutoGroup(anyString());
verify(mCallback, never()).removeAutoGroupSummary(anyInt(), anyString());
verify(mCallback).updateAutogroupSummary(anyInt(), anyString(), eq(BASE_FLAGS));
verify(mCallback, never()).addAutoGroupSummary(
anyInt(), anyString(), anyString(), anyInt());
}
}

83
services/tests/uiservicestests/src/com/android/server/notification/NotificationManagerServiceTest.java
View File

@@ -754,13 +754,19 @@ public class NotificationManagerServiceTest extends UiServiceTestCase {
private NotificationRecord generateNotificationRecord(NotificationChannel channel, int id,
String groupKey, boolean isSummary) {
return generateNotificationRecord(channel, id, "tag" + System.currentTimeMillis(), groupKey,
isSummary);
}
private NotificationRecord generateNotificationRecord(NotificationChannel channel, int id,
String tag, String groupKey, boolean isSummary) {
Notification.Builder nb = new Notification.Builder(mContext, channel.getId())
.setContentTitle("foo")
.setSmallIcon(android.R.drawable.sym_def_app_icon)
.setGroup(groupKey)
.setGroupSummary(isSummary);
StatusBarNotification sbn = new StatusBarNotification(PKG, PKG, id,
"tag" + System.currentTimeMillis(), mUid, 0,
tag, mUid, 0,
nb.build(), UserHandle.getUserHandleForUid(mUid), null, 0);
return new NotificationRecord(mContext, sbn, channel);
}
@@ -1899,7 +1905,8 @@ public class NotificationManagerServiceTest extends UiServiceTestCase {
mService.mSummaryByGroupKey.put("pkg", summary);
mService.mAutobundledSummaries.put(0, new ArrayMap<>());
mService.mAutobundledSummaries.get(0).put("pkg", summary.getKey());
mService.updateAutobundledSummaryFlags(0, "pkg", true, false);
mService.updateAutobundledSummaryFlags(
0, "pkg", GroupHelper.BASE_FLAGS | FLAG_ONGOING_EVENT, false);
assertTrue(summary.getSbn().isOngoing());
}
@@ -1915,7 +1922,7 @@ public class NotificationManagerServiceTest extends UiServiceTestCase {
mService.mAutobundledSummaries.get(0).put("pkg", summary.getKey());
mService.mSummaryByGroupKey.put("pkg", summary);
mService.updateAutobundledSummaryFlags(0, "pkg", false, false);
mService.updateAutobundledSummaryFlags(0, "pkg", GroupHelper.BASE_FLAGS, false);
assertFalse(summary.getSbn().isOngoing());
}
@@ -2897,7 +2904,7 @@ public class NotificationManagerServiceTest extends UiServiceTestCase {
when(mPermissionHelper.isPermissionFixed(PKG, temp.getUserId())).thenReturn(true);
NotificationRecord r = mService.createAutoGroupSummary(
temp.getUserId(), temp.getSbn().getPackageName(), temp.getKey(), false);
temp.getUserId(), temp.getSbn().getPackageName(), temp.getKey(), 0);
assertThat(r.isImportanceFixed()).isTrue();
}
@@ -4213,7 +4220,7 @@ public class NotificationManagerServiceTest extends UiServiceTestCase {
}
@Test
public void testOnlyAutogroupIfGroupChanged_noPriorNoti_autogroups() throws Exception {
public void testOnlyAutogroupIfNeeded_newNotification_ghUpdate() {
NotificationRecord r = generateNotificationRecord(mTestNotificationChannel, 0, null, false);
mService.addEnqueuedNotification(r);
NotificationManagerService.PostNotificationRunnable runnable =
@@ -4226,17 +4233,18 @@ public class NotificationManagerServiceTest extends UiServiceTestCase {
}
@Test
public void testOnlyAutogroupIfGroupChanged_groupChanged_autogroups()
throws Exception {
NotificationRecord r =
generateNotificationRecord(mTestNotificationChannel, 0, "group", false);
public void testOnlyAutogroupIfNeeded_groupChanged_ghUpdate() {
NotificationRecord r = generateNotificationRecord(mTestNotificationChannel, 0,
"testOnlyAutogroupIfNeeded_groupChanged_ghUpdate", "group", false);
mService.addNotification(r);
r = generateNotificationRecord(mTestNotificationChannel, 0, null, false);
mService.addEnqueuedNotification(r);
NotificationRecord update = generateNotificationRecord(mTestNotificationChannel, 0,
"testOnlyAutogroupIfNeeded_groupChanged_ghUpdate", null, false);
mService.addEnqueuedNotification(update);
NotificationManagerService.PostNotificationRunnable runnable =
mService.new PostNotificationRunnable(r.getKey(), r.getSbn().getPackageName(),
r.getUid(), SystemClock.elapsedRealtime());
mService.new PostNotificationRunnable(update.getKey(),
update.getSbn().getPackageName(), update.getUid(),
SystemClock.elapsedRealtime());
runnable.run();
waitForIdle();
@@ -4244,16 +4252,39 @@ public class NotificationManagerServiceTest extends UiServiceTestCase {
}
@Test
public void testOnlyAutogroupIfGroupChanged_noGroupChanged_autogroups()
throws Exception {
NotificationRecord r = generateNotificationRecord(mTestNotificationChannel, 0, "group",
false);
public void testOnlyAutogroupIfNeeded_flagsChanged_ghUpdate() {
NotificationRecord r = generateNotificationRecord(mTestNotificationChannel, 0,
"testOnlyAutogroupIfNeeded_flagsChanged_ghUpdate", "group", false);
mService.addNotification(r);
mService.addEnqueuedNotification(r);
NotificationRecord update = generateNotificationRecord(mTestNotificationChannel, 0,
"testOnlyAutogroupIfNeeded_flagsChanged_ghUpdate", null, false);
update.getNotification().flags = FLAG_AUTO_CANCEL;
mService.addEnqueuedNotification(update);
NotificationManagerService.PostNotificationRunnable runnable =
mService.new PostNotificationRunnable(update.getKey(),
update.getSbn().getPackageName(), update.getUid(),
SystemClock.elapsedRealtime());
runnable.run();
waitForIdle();
verify(mGroupHelper, times(1)).onNotificationPosted(any(), anyBoolean());
}
@Test
public void testOnlyAutogroupIfGroupChanged_noValidChange_noGhUpdate() {
NotificationRecord r = generateNotificationRecord(mTestNotificationChannel, 0,
"testOnlyAutogroupIfGroupChanged_noValidChange_noGhUpdate", null, false);
mService.addNotification(r);
NotificationRecord update = generateNotificationRecord(mTestNotificationChannel, 0,
"testOnlyAutogroupIfGroupChanged_noValidChange_noGhUpdate", null, false);
update.getNotification().color = Color.BLACK;
mService.addEnqueuedNotification(update);
NotificationManagerService.PostNotificationRunnable runnable =
mService.new PostNotificationRunnable(r.getKey(), r.getSbn().getPackageName(),
r.getUid(), SystemClock.elapsedRealtime());
mService.new PostNotificationRunnable(update.getKey(),
update.getSbn().getPackageName(),
update.getUid(), SystemClock.elapsedRealtime());
runnable.run();
waitForIdle();
@@ -10220,10 +10251,10 @@ public class NotificationManagerServiceTest extends UiServiceTestCase {
// grouphelper is a mock here, so make the calls it would make
// add summary; wait for it to be posted
mService.addAutoGroupSummary(nr1.getUserId(), nr1.getSbn().getPackageName(), nr1.getKey(),
true);
waitForIdle();
// add summary
mService.addNotification(mService.createAutoGroupSummary(nr1.getUserId(),
nr1.getSbn().getPackageName(), nr1.getKey(),
GroupHelper.BASE_FLAGS | FLAG_ONGOING_EVENT));
// cancel both children
mBinderService.cancelNotificationWithTag(PKG, PKG, nr0.getSbn().getTag(),
@@ -10232,9 +10263,7 @@ public class NotificationManagerServiceTest extends UiServiceTestCase {
nr1.getSbn().getId(), nr1.getSbn().getUserId());
waitForIdle();
// group helper would send 'remove flag' and then 'remove summary' events
mService.updateAutobundledSummaryFlags(nr1.getUserId(), nr1.getSbn().getPackageName(),
false, false);
// group helper would send 'remove summary' event
mService.clearAutogroupSummaryLocked(nr1.getUserId(), nr1.getSbn().getPackageName());
waitForIdle();

35
services/tests/uiservicestests/src/com/android/server/notification/NotificationRecordExtractorDataTest.java
View File

@@ -97,6 +97,41 @@ public class NotificationRecordExtractorDataTest extends UiServiceTestCase {
assertTrue(extractorData.hasDiffForLoggingLocked(r, 1));
}
@Test
public void testHasDiffs_autoBundled() {
NotificationRecord r = generateRecord();
NotificationRecordExtractorData extractorData = new NotificationRecordExtractorData(
1,
r.getPackageVisibilityOverride(),
r.canShowBadge(),
r.canBubble(),
r.getNotification().isBubbleNotification(),
r.getChannel(),
r.getGroupKey(),
r.getPeopleOverride(),
r.getSnoozeCriteria(),
r.getUserSentiment(),
r.getSuppressedVisualEffects(),
r.getSystemGeneratedSmartActions(),
r.getSmartReplies(),
r.getImportance(),
r.getRankingScore(),
r.isConversation(),
r.getProposedImportance(),
r.hasSensitiveContent());
Bundle signals = new Bundle();
signals.putString(Adjustment.KEY_GROUP_KEY, "ranker_group");
Adjustment adjustment = new Adjustment("pkg", r.getKey(), signals, "", 0);
r.addAdjustment(adjustment);
NotificationAdjustmentExtractor adjustmentExtractor = new NotificationAdjustmentExtractor();
adjustmentExtractor.process(r);
assertTrue(extractorData.hasDiffForRankingLocked(r, 1));
assertTrue(extractorData.hasDiffForLoggingLocked(r, 1));
}
@Test
public void testHasDiffs_sensitiveContentChange() {
NotificationRecord r = generateRecord();