Regroup app-grouped notifications after classification (7b433205) · Commits · e / os / android_frameworks_base

core/java/android/service/notification/flags.aconfig

+8 −1

Original line number	Original line	Diff line number	Diff line
	@@ -66,3 +66,10 @@ flag {
	description: "Allows the NAS to create and modify conversation notifications"		description: "Allows the NAS to create and modify conversation notifications"
	bug: "373599715"		bug: "373599715"
	}		}

			flag {
			name: "notification_regroup_on_classification"
			namespace: "systemui"
			description: "This flag controls regrouping after notification classification"
			bug: "372775153"
			}

services/core/java/com/android/server/notification/GroupHelper.java

+170 −4

Original line number	Original line	Diff line number	Diff line
	@@ -25,8 +25,10 @@ import static android.app.Notification.FLAG_ONGOING_EVENT;
	import static android.app.Notification.VISIBILITY_PRIVATE;		import static android.app.Notification.VISIBILITY_PRIVATE;
	import static android.app.Notification.VISIBILITY_PUBLIC;		import static android.app.Notification.VISIBILITY_PUBLIC;
	import static android.service.notification.Flags.notificationForceGrouping;		import static android.service.notification.Flags.notificationForceGrouping;
			import static android.service.notification.Flags.notificationRegroupOnClassification;

	import android.annotation.FlaggedApi;		import android.annotation.FlaggedApi;
			import android.annotation.IntDef;
	import android.annotation.NonNull;		import android.annotation.NonNull;
	import android.annotation.Nullable;		import android.annotation.Nullable;
	import android.app.ActivityManager;		import android.app.ActivityManager;
	@@ -49,6 +51,9 @@ import com.android.internal.R;
	import com.android.internal.annotations.GuardedBy;		import com.android.internal.annotations.GuardedBy;
	import com.android.internal.annotations.VisibleForTesting;		import com.android.internal.annotations.VisibleForTesting;

			import java.io.PrintWriter;
			import java.lang.annotation.Retention;
			import java.lang.annotation.RetentionPolicy;
	import java.util.ArrayList;		import java.util.ArrayList;
	import java.util.Collection;		import java.util.Collection;
	import java.util.HashSet;		import java.util.HashSet;
	@@ -83,10 +88,22 @@ public class GroupHelper {
	// with less than this value, they will be forced grouped		// with less than this value, they will be forced grouped
	private static final int MIN_CHILD_COUNT_TO_AVOID_FORCE_GROUPING = 3;		private static final int MIN_CHILD_COUNT_TO_AVOID_FORCE_GROUPING = 3;

			// Regrouping needed because the channel was updated, ie. importance changed
			static final int REGROUP_REASON_CHANNEL_UPDATE = 0;
			// Regrouping needed because of notification bundling
			static final int REGROUP_REASON_BUNDLE = 1;

			@IntDef(prefix = { "REGROUP_REASON_" }, value = {
			REGROUP_REASON_CHANNEL_UPDATE,
			REGROUP_REASON_BUNDLE,
			})
			@Retention(RetentionPolicy.SOURCE)
			@interface RegroupingReason {}

	private final Callback mCallback;		private final Callback mCallback;
	private final int mAutoGroupAtCount;		private final int mAutoGroupAtCount;
	private final int mAutogroupSparseGroupsAtCount;		private final int mAutogroupSparseGroupsAtCount;
			private final int mAutoGroupRegroupingAtCount;
	private final Context mContext;		private final Context mContext;
	private final PackageManager mPackageManager;		private final PackageManager mPackageManager;
	private boolean mIsTestHarnessExempted;		private boolean mIsTestHarnessExempted;
	@@ -173,6 +190,11 @@ public class GroupHelper {
	mContext = context;		mContext = context;
	mPackageManager = packageManager;		mPackageManager = packageManager;
	mAutogroupSparseGroupsAtCount = autoGroupSparseGroupsAtCount;		mAutogroupSparseGroupsAtCount = autoGroupSparseGroupsAtCount;
			if (notificationRegroupOnClassification()) {
			mAutoGroupRegroupingAtCount = 1;
			} else {
			mAutoGroupRegroupingAtCount = mAutoGroupAtCount;
			}
	NOTIFICATION_SHADE_SECTIONS = getNotificationShadeSections();		NOTIFICATION_SHADE_SECTIONS = getNotificationShadeSections();
	}		}

	@@ -865,7 +887,8 @@ public class GroupHelper {
	}		}
	}		}

	regroupNotifications(userId, pkgName, notificationsToCheck);		regroupNotifications(userId, pkgName, notificationsToCheck,
			REGROUP_REASON_CHANNEL_UPDATE);
	}		}
	}		}

	@@ -883,13 +906,14 @@ public class GroupHelper {
	ArrayMap<String, NotificationRecord> notificationsToCheck = new ArrayMap<>();		ArrayMap<String, NotificationRecord> notificationsToCheck = new ArrayMap<>();
	notificationsToCheck.put(record.getKey(), record);		notificationsToCheck.put(record.getKey(), record);
	regroupNotifications(record.getUserId(), record.getSbn().getPackageName(),		regroupNotifications(record.getUserId(), record.getSbn().getPackageName(),
	notificationsToCheck);		notificationsToCheck, REGROUP_REASON_BUNDLE);
	}		}
	}		}

	@GuardedBy("mAggregatedNotifications")		@GuardedBy("mAggregatedNotifications")
	private void regroupNotifications(int userId, String pkgName,		private void regroupNotifications(int userId, String pkgName,
	ArrayMap<String, NotificationRecord> notificationsToCheck) {		ArrayMap<String, NotificationRecord> notificationsToCheck,
			@RegroupingReason int regroupingReason) {
	// The list of notification operations required after the channel update		// The list of notification operations required after the channel update
	final ArrayList<NotificationMoveOp> notificationsToMove = new ArrayList<>();		final ArrayList<NotificationMoveOp> notificationsToMove = new ArrayList<>();

	@@ -904,12 +928,42 @@ public class GroupHelper {
	notificationsToMove.addAll(		notificationsToMove.addAll(
	getUngroupedNotificationsMoveOps(userId, pkgName, notificationsToCheck));		getUngroupedNotificationsMoveOps(userId, pkgName, notificationsToCheck));

			// Handle "grouped correctly" notifications that were re-classified (bundled)
			if (notificationRegroupOnClassification()) {
			if (regroupingReason == REGROUP_REASON_BUNDLE) {
			notificationsToMove.addAll(
			getReclassifiedNotificationsMoveOps(userId, pkgName, notificationsToCheck));
			}
			}

	// Batch move to new section		// Batch move to new section
	if (!notificationsToMove.isEmpty()) {		if (!notificationsToMove.isEmpty()) {
	moveNotificationsToNewSection(userId, pkgName, notificationsToMove);		moveNotificationsToNewSection(userId, pkgName, notificationsToMove);
	}		}
	}		}

			private List<NotificationMoveOp> getReclassifiedNotificationsMoveOps(int userId,
			String pkgName, ArrayMap<String, NotificationRecord> notificationsToCheck) {
			final ArrayList<NotificationMoveOp> notificationsToMove = new ArrayList<>();
			for (NotificationRecord record : notificationsToCheck.values()) {
			if (isChildOfValidAppGroup(record)) {
			// Check if section changes
			NotificationSectioner sectioner = getSection(record);
			if (sectioner != null) {
			FullyQualifiedGroupKey newFullAggregateGroupKey =
			new FullyQualifiedGroupKey(userId, pkgName, sectioner);
			if (DEBUG) {
			Slog.v(TAG, "Regroup after classification: " + record + " to: "
			+ newFullAggregateGroupKey);
			}
			notificationsToMove.add(
			new NotificationMoveOp(record, null, newFullAggregateGroupKey));
			}
			}
			}
			return notificationsToMove;
			}

	@GuardedBy("mAggregatedNotifications")		@GuardedBy("mAggregatedNotifications")
	private List<NotificationMoveOp> getAutogroupedNotificationsMoveOps(int userId, String pkgName,		private List<NotificationMoveOp> getAutogroupedNotificationsMoveOps(int userId, String pkgName,
	ArrayMap<String, NotificationRecord> notificationsToCheck) {		ArrayMap<String, NotificationRecord> notificationsToCheck) {
	@@ -1010,6 +1064,10 @@ public class GroupHelper {
	// Bundled operations to apply to groups affected by the channel update		// Bundled operations to apply to groups affected by the channel update
	ArrayMap<FullyQualifiedGroupKey, GroupUpdateOp> groupsToUpdate = new ArrayMap<>();		ArrayMap<FullyQualifiedGroupKey, GroupUpdateOp> groupsToUpdate = new ArrayMap<>();

			// App-provided (valid) groups of notifications that were classified (bundled).
			// Summaries will be canceled if all child notifications have been bundled.
			ArrayMap<String, String> originalGroupsOfBundledNotifications = new ArrayMap<>();

	for (NotificationMoveOp moveOp: notificationsToMove) {		for (NotificationMoveOp moveOp: notificationsToMove) {
	final NotificationRecord record = moveOp.record;		final NotificationRecord record = moveOp.record;
	final FullyQualifiedGroupKey oldFullAggregateGroupKey = moveOp.oldGroup;		final FullyQualifiedGroupKey oldFullAggregateGroupKey = moveOp.oldGroup;
	@@ -1035,6 +1093,13 @@ public class GroupHelper {
	groupsToUpdate.put(oldFullAggregateGroupKey,		groupsToUpdate.put(oldFullAggregateGroupKey,
	new GroupUpdateOp(oldFullAggregateGroupKey, record, true));		new GroupUpdateOp(oldFullAggregateGroupKey, record, true));
	}		}
			} else {
			if (notificationRegroupOnClassification()) {
			// Null "old aggregate group" => this notification was re-classified from
			// a valid app-provided group => maybe cancel the original summary
			// if no children are left
			originalGroupsOfBundledNotifications.put(record.getKey(), record.getGroupKey());
			}
	}		}

	// Add moved notifications to the ungrouped list for new group and do grouping		// Add moved notifications to the ungrouped list for new group and do grouping
	@@ -1076,7 +1141,7 @@ public class GroupHelper {
	NotificationRecord triggeringNotification = groupsToUpdate.get(groupKey).record;		NotificationRecord triggeringNotification = groupsToUpdate.get(groupKey).record;
	boolean hasSummary = groupsToUpdate.get(groupKey).hasSummary;		boolean hasSummary = groupsToUpdate.get(groupKey).hasSummary;
	//Group needs to be created/updated		//Group needs to be created/updated
	if (ungrouped.size() >= mAutoGroupAtCount		if (ungrouped.size() >= mAutoGroupRegroupingAtCount
	\|\| (hasSummary && !aggregatedNotificationsAttrs.isEmpty())) {		\|\| (hasSummary && !aggregatedNotificationsAttrs.isEmpty())) {
	NotificationSectioner sectioner = getSection(triggeringNotification);		NotificationSectioner sectioner = getSection(triggeringNotification);
	if (sectioner == null) {		if (sectioner == null) {
	@@ -1092,6 +1157,18 @@ public class GroupHelper {
	}		}
	}		}
	}		}

			if (notificationRegroupOnClassification()) {
			// Cancel the summary if it's the last notification of the original app-provided group
			for (String triggeringKey : originalGroupsOfBundledNotifications.keySet()) {
			NotificationRecord canceledSummary =
			mCallback.removeAppProvidedSummaryOnClassification(triggeringKey,
			originalGroupsOfBundledNotifications.getOrDefault(triggeringKey, null));
			if (canceledSummary != null) {
			cacheCanceledSummary(canceledSummary);
			}
			}
			}
	}		}

	static String getFullAggregateGroupKey(String pkgName,		static String getFullAggregateGroupKey(String pkgName,
	@@ -1113,6 +1190,42 @@ public class GroupHelper {
	return (record.mOriginalFlags & Notification.FLAG_AUTOGROUP_SUMMARY) != 0;		return (record.mOriginalFlags & Notification.FLAG_AUTOGROUP_SUMMARY) != 0;
	}		}

			private boolean isNotificationAggregatedInSection(NotificationRecord record,
			NotificationSectioner sectioner) {
			final FullyQualifiedGroupKey fullAggregateGroupKey = new FullyQualifiedGroupKey(
			record.getUserId(), record.getSbn().getPackageName(), sectioner);
			return record.getGroupKey().equals(fullAggregateGroupKey.toString());
			}

			private boolean isChildOfValidAppGroup(NotificationRecord record) {
			final StatusBarNotification sbn = record.getSbn();
			if (!sbn.isAppGroup()) {
			return false;
			}

			if (!sbn.getNotification().isGroupChild()) {
			return false;
			}

			if (record.isCanceled) {
			return false;
			}

			final NotificationSectioner sectioner = getSection(record);
			if (sectioner == null) {
			if (DEBUG) {
			Slog.i(TAG, "Skipping autogrouping for " + record + " no valid section found.");
			}
			return false;
			}

			if (isNotificationAggregatedInSection(record, sectioner)) {
			return false;
			}

			return true;
			}

	private static int getNumChildrenForGroup(@NonNull final String groupKey,		private static int getNumChildrenForGroup(@NonNull final String groupKey,
	final List<NotificationRecord> notificationList) {		final List<NotificationRecord> notificationList) {
	//TODO (b/349072751): track grouping state in GroupHelper -> do not use notificationList		//TODO (b/349072751): track grouping state in GroupHelper -> do not use notificationList
	@@ -1438,6 +1551,48 @@ public class GroupHelper {
	}		}
	}		}

			protected void dump(PrintWriter pw, String prefix) {
			synchronized (mAggregatedNotifications) {
			if (!mUngroupedAbuseNotifications.isEmpty()) {
			pw.println(prefix + "Ungrouped notifications:");
			for (FullyQualifiedGroupKey groupKey: mUngroupedAbuseNotifications.keySet()) {
			if (!mUngroupedAbuseNotifications.getOrDefault(groupKey, new ArrayMap<>())
			.isEmpty()) {
			pw.println(prefix + prefix + groupKey.toString());
			for (String notifKey : mUngroupedAbuseNotifications.get(groupKey)
			.keySet()) {
			pw.println(prefix + prefix + prefix + notifKey);
			}
			}
			}
			pw.println("");
			}

			if (!mAggregatedNotifications.isEmpty()) {
			pw.println(prefix + "Autogrouped notifications:");
			for (FullyQualifiedGroupKey groupKey: mAggregatedNotifications.keySet()) {
			if (!mAggregatedNotifications.getOrDefault(groupKey, new ArrayMap<>())
			.isEmpty()) {
			pw.println(prefix + prefix + groupKey.toString());
			for (String notifKey : mAggregatedNotifications.get(groupKey).keySet()) {
			pw.println(prefix + prefix + prefix + notifKey);
			}
			}
			}
			pw.println("");
			}

			if (!mCanceledSummaries.isEmpty()) {
			pw.println(prefix + "Cached canceled summaries:");
			for (CachedSummary summary: mCanceledSummaries.values()) {
			pw.println(prefix + prefix + prefix + summary.key + " -> "
			+ summary.originalGroupKey);
			}
			pw.println("");
			}
			}
			}

	protected static class NotificationSectioner {		protected static class NotificationSectioner {
	final String mName;		final String mName;
	final int mSummaryId;		final int mSummaryId;
	@@ -1551,5 +1706,16 @@ public class GroupHelper {

	void removeNotificationFromCanceledGroup(int userId, String pkg, String groupKey,		void removeNotificationFromCanceledGroup(int userId, String pkg, String groupKey,
	int cancelReason);		int cancelReason);

			/**
			* Cancels the group summary of a notification that was regrouped because of classification
			* (bundling). Only cancels if the summary is the last notification of the original group.
			* @param triggeringKey the triggering child notification key
			* @param groupKey the original group key
			* @return the canceled group summary or null if the summary was not canceled
			*/
			@Nullable
			NotificationRecord removeAppProvidedSummaryOnClassification(String triggeringKey,
			@Nullable String groupKey);
	}		}
	}		}

services/core/java/com/android/server/notification/NotificationManagerService.java

+59 −0

Original line number	Original line	Diff line number	Diff line
	@@ -2998,6 +2998,16 @@ public class NotificationManagerService extends SystemService {
	groupKey, REASON_APP_CANCEL, SystemClock.elapsedRealtime());		groupKey, REASON_APP_CANCEL, SystemClock.elapsedRealtime());
	}		}
	}		}

			@Override
			@Nullable
			public NotificationRecord removeAppProvidedSummaryOnClassification(String triggeringKey,
			@Nullable String oldGroupKey) {
			synchronized (mNotificationLock) {
			return removeAppProvidedSummaryOnClassificationLocked(triggeringKey,
			oldGroupKey);
			}
			}
	});		});
	}		}

	@@ -7113,6 +7123,50 @@ public class NotificationManagerService extends SystemService {
	}		}
	}		}

			@GuardedBy("mNotificationLock")
			@Nullable
			NotificationRecord removeAppProvidedSummaryOnClassificationLocked(String triggeringKey,
			@Nullable String oldGroupKey) {
			NotificationRecord canceledSummary = null;
			NotificationRecord r = mNotificationsByKey.get(triggeringKey);
			if (r == null \|\| oldGroupKey == null) {
			return null;
			}

			if (r.getSbn().isAppGroup() && r.getNotification().isGroupChild()) {
			NotificationRecord groupSummary = mSummaryByGroupKey.get(oldGroupKey);
			// We only care about app-provided valid groups
			if (groupSummary != null && !GroupHelper.isAggregatedGroup(groupSummary)) {
			List<NotificationRecord> notificationsInGroup =
			findGroupNotificationsLocked(r.getSbn().getPackageName(),
			oldGroupKey, r.getUserId());
			// Remove the app-provided summary if only the summary is left in the
			// original group, or summary + triggering notification that will be
			// regrouped
			boolean isOnlySummaryLeft =
			(notificationsInGroup.size() <= 1)
			\|\| (notificationsInGroup.size() == 2
			&& notificationsInGroup.contains(r)
			&& notificationsInGroup.contains(groupSummary));
			if (isOnlySummaryLeft) {
			if (DBG) {
			Slog.i(TAG, "Removing app summary (all children bundled): "
			+ groupSummary);
			}
			canceledSummary = groupSummary;
			mSummaryByGroupKey.remove(oldGroupKey);
			cancelNotification(Binder.getCallingUid(), Binder.getCallingPid(),
			groupSummary.getSbn().getPackageName(),
			groupSummary.getSbn().getTag(),
			groupSummary.getSbn().getId(), 0, 0, false, groupSummary.getUserId(),
			NotificationListenerService.REASON_GROUP_OPTIMIZATION, null);
			}
			}
			}

			return canceledSummary;
			}

	@GuardedBy("mNotificationLock")		@GuardedBy("mNotificationLock")
	private boolean hasAutoGroupSummaryLocked(NotificationRecord record) {		private boolean hasAutoGroupSummaryLocked(NotificationRecord record) {
	final String autbundledGroupKey;		final String autbundledGroupKey;
	@@ -7493,6 +7547,11 @@ public class NotificationManagerService extends SystemService {
	mTtlHelper.dump(pw, " ");		mTtlHelper.dump(pw, " ");
	}		}
	}		}

			if (notificationForceGrouping()) {
			pw.println("\n GroupHelper:");
			mGroupHelper.dump(pw, " ");
			}
	}		}
	}		}

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

+360 −5

File changed.

Preview size limit exceeded, changes collapsed.

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

+36 −0

Original line number	Original line	Diff line number	Diff line
	@@ -114,6 +114,7 @@ import static android.service.notification.Condition.STATE_TRUE;
	import static android.service.notification.Flags.FLAG_NOTIFICATION_CLASSIFICATION;		import static android.service.notification.Flags.FLAG_NOTIFICATION_CLASSIFICATION;
	import static android.service.notification.Flags.FLAG_NOTIFICATION_CONVERSATION_CHANNEL_MANAGEMENT;		import static android.service.notification.Flags.FLAG_NOTIFICATION_CONVERSATION_CHANNEL_MANAGEMENT;
	import static android.service.notification.Flags.FLAG_NOTIFICATION_FORCE_GROUPING;		import static android.service.notification.Flags.FLAG_NOTIFICATION_FORCE_GROUPING;
			import static android.service.notification.Flags.FLAG_NOTIFICATION_REGROUP_ON_CLASSIFICATION;
	import static android.service.notification.Flags.FLAG_REDACT_SENSITIVE_NOTIFICATIONS_FROM_UNTRUSTED_LISTENERS;		import static android.service.notification.Flags.FLAG_REDACT_SENSITIVE_NOTIFICATIONS_FROM_UNTRUSTED_LISTENERS;
	import static android.service.notification.NotificationListenerService.FLAG_FILTER_TYPE_ALERTING;		import static android.service.notification.NotificationListenerService.FLAG_FILTER_TYPE_ALERTING;
	import static android.service.notification.NotificationListenerService.FLAG_FILTER_TYPE_CONVERSATIONS;		import static android.service.notification.NotificationListenerService.FLAG_FILTER_TYPE_CONVERSATIONS;
	@@ -2684,6 +2685,41 @@ public class NotificationManagerServiceTest extends UiServiceTestCase {
	verify(mWorkerHandler, times(1)).scheduleCancelNotification(any(), eq(0));		verify(mWorkerHandler, times(1)).scheduleCancelNotification(any(), eq(0));
	}		}

			@Test
			@EnableFlags({FLAG_NOTIFICATION_FORCE_GROUPING, FLAG_NOTIFICATION_REGROUP_ON_CLASSIFICATION})
			public void testAggregateGroups_RemoveAppSummary_onClassification() throws Exception {
			final String originalGroupName = "originalGroup";
			final int summaryId = 0;
			final NotificationRecord r1 = generateNotificationRecord(mTestNotificationChannel,
			summaryId + 1, originalGroupName, false);
			mService.addNotification(r1);
			final NotificationRecord r2 = generateNotificationRecord(mTestNotificationChannel,
			summaryId + 2, originalGroupName, false);
			mService.addNotification(r2);
			final NotificationRecord summary = generateNotificationRecord(mTestNotificationChannel,
			summaryId, originalGroupName, true);
			mService.addNotification(summary);
			final String originalGroupKey = summary.getGroupKey();
			assertThat(mService.mSummaryByGroupKey).containsEntry(originalGroupKey, summary);

			// Regroup first child notification
			r1.setOverrideGroupKey("newGroup");
			// Check that removeAppProvidedSummaryOnClassificationLocked is null
			// => there is still one child left in the original group
			assertThat(mService.removeAppProvidedSummaryOnClassificationLocked(r1.getKey(),
			originalGroupKey)).isNull();

			// Regroup last child notification
			r2.setOverrideGroupKey("newGroup");
			// Check that removeAppProvidedSummaryOnClassificationLocked returns the original summary
			// and that the original app-provided summary is canceled
			assertThat(mService.removeAppProvidedSummaryOnClassificationLocked(r2.getKey(),
			originalGroupKey)).isEqualTo(summary);
			waitForIdle();
			verify(mWorkerHandler, times(1)).scheduleCancelNotification(any(), eq(summaryId));
			assertThat(mService.mSummaryByGroupKey).doesNotContainKey(originalGroupKey);
			}

	@Test		@Test
	@EnableFlags(FLAG_NOTIFICATION_FORCE_GROUPING)		@EnableFlags(FLAG_NOTIFICATION_FORCE_GROUPING)
	public void testUngroupingAggregateSummary() throws Exception {		public void testUngroupingAggregateSummary() throws Exception {