Add GroupCoalescer to new pipeline
Adds the GroupCoalescer, which attempts to make posting notification
groups an atomic action. Currently, notif groups are posted in pieces,
with one post per child or summary. As a result, downstream code can't
tell whether a group is currently complete or whether more stuff is
coming down the line. This complicates a lot of logic, especially to do
with heads-upping.
The GroupCoalescer sits between the NotificationListener and the
NotifCollection and controls the flow of notification events between the
two. As a result, the full pipeline is now:
NotificationListener -> GroupCoalescer -> NotifCollection ->
NotifListBuilderImpl
Most events pass through the GroupCoalescer unhindered, but any event
that involves posting a grouped notification is temporarily delayed
within the coalescer to see if any other similar events occur. When the
delay times out, all delayed events for that group are posted to the
NotifCollection in a batch.
It's dangerous to reorder or delay events from the NotificationListener
for too long, so any event that would further modify the group, such as
updating or removing one of the delayed notifications, causes the batch
to be immediately emitted, followed by the modifying event.
Test: atest SystemUITests
Change-Id: I4b5dd1a6acb3a7704b2e199a5ed42fe855ab74cb
diff --git a/packages/SystemUI/src/com/android/systemui/statusbar/notification/collection/NotifCollection.java b/packages/SystemUI/src/com/android/systemui/statusbar/notification/collection/NotifCollection.java
index f5f1766..873cdbc 100644
--- a/packages/SystemUI/src/com/android/systemui/statusbar/notification/collection/NotifCollection.java
+++ b/packages/SystemUI/src/com/android/systemui/statusbar/notification/collection/NotifCollection.java
@@ -47,8 +47,9 @@
import android.util.Log;
import com.android.internal.statusbar.IStatusBarService;
-import com.android.systemui.statusbar.NotificationListener;
-import com.android.systemui.statusbar.NotificationListener.NotificationHandler;
+import com.android.systemui.statusbar.notification.collection.notifcollection.CoalescedEvent;
+import com.android.systemui.statusbar.notification.collection.notifcollection.GroupCoalescer;
+import com.android.systemui.statusbar.notification.collection.notifcollection.GroupCoalescer.BatchableNotificationHandler;
import com.android.systemui.util.Assert;
import java.lang.annotation.Retention;
@@ -108,14 +109,14 @@
}
/** Initializes the NotifCollection and registers it to receive notification events. */
- public void attach(NotificationListener listenerService) {
+ public void attach(GroupCoalescer groupCoalescer) {
Assert.isMainThread();
if (mAttached) {
throw new RuntimeException("attach() called twice");
}
mAttached = true;
- listenerService.addNotificationHandler(mNotificationHandler);
+ groupCoalescer.setNotificationHandler(mNotifHandler);
}
/**
@@ -178,15 +179,52 @@
private void onNotificationPosted(StatusBarNotification sbn, RankingMap rankingMap) {
Assert.isMainThread();
+ postNotification(sbn, requireRanking(rankingMap, sbn.getKey()), rankingMap);
+ rebuildList();
+ }
+
+ private void onNotificationGroupPosted(List<CoalescedEvent> batch) {
+ Assert.isMainThread();
+
+ Log.d(TAG, "POSTED GROUP " + batch.get(0).getSbn().getGroupKey()
+ + " (" + batch.size() + " events)");
+ for (CoalescedEvent event : batch) {
+ postNotification(event.getSbn(), event.getRanking(), null);
+ }
+ rebuildList();
+ }
+
+ private void onNotificationRemoved(
+ StatusBarNotification sbn,
+ RankingMap rankingMap,
+ int reason) {
+ Assert.isMainThread();
+
+ Log.d(TAG, "REMOVED " + sbn.getKey() + " reason=" + reason);
+ removeNotification(sbn.getKey(), rankingMap, reason, null);
+ }
+
+ private void onNotificationRankingUpdate(RankingMap rankingMap) {
+ Assert.isMainThread();
+ applyRanking(rankingMap);
+ rebuildList();
+ }
+
+ private void postNotification(
+ StatusBarNotification sbn,
+ Ranking ranking,
+ @Nullable RankingMap rankingMap) {
NotificationEntry entry = mNotificationSet.get(sbn.getKey());
if (entry == null) {
// A new notification!
Log.d(TAG, "POSTED " + sbn.getKey());
- entry = new NotificationEntry(sbn, requireRanking(rankingMap, sbn.getKey()));
+ entry = new NotificationEntry(sbn, ranking);
mNotificationSet.put(sbn.getKey(), entry);
- applyRanking(rankingMap);
+ if (rankingMap != null) {
+ applyRanking(rankingMap);
+ }
dispatchOnEntryAdded(entry);
@@ -199,34 +237,19 @@
cancelLifetimeExtension(entry);
entry.setSbn(sbn);
- applyRanking(rankingMap);
+ if (rankingMap != null) {
+ applyRanking(rankingMap);
+ }
dispatchOnEntryUpdated(entry);
}
-
- rebuildList();
- }
-
- private void onNotificationRemoved(
- StatusBarNotification sbn,
- @Nullable RankingMap rankingMap,
- int reason) {
- Assert.isMainThread();
- Log.d(TAG, "REMOVED " + sbn.getKey() + " reason=" + reason);
- removeNotification(sbn.getKey(), rankingMap, reason, null);
- }
-
- private void onNotificationRankingUpdate(RankingMap rankingMap) {
- Assert.isMainThread();
- applyRanking(rankingMap);
- rebuildList();
}
private void removeNotification(
String key,
@Nullable RankingMap rankingMap,
@CancellationReason int reason,
- DismissedByUserStats dismissedByUserStats) {
+ @Nullable DismissedByUserStats dismissedByUserStats) {
NotificationEntry entry = mNotificationSet.get(key);
if (entry == null) {
@@ -271,7 +294,7 @@
rebuildList();
}
- private void applyRanking(RankingMap rankingMap) {
+ private void applyRanking(@NonNull RankingMap rankingMap) {
for (NotificationEntry entry : mNotificationSet.values()) {
if (!isLifetimeExtended(entry)) {
Ranking ranking = requireRanking(rankingMap, entry.getKey());
@@ -363,13 +386,18 @@
mAmDispatchingToOtherCode = false;
}
- private final NotificationHandler mNotificationHandler = new NotificationHandler() {
+ private final BatchableNotificationHandler mNotifHandler = new BatchableNotificationHandler() {
@Override
public void onNotificationPosted(StatusBarNotification sbn, RankingMap rankingMap) {
NotifCollection.this.onNotificationPosted(sbn, rankingMap);
}
@Override
+ public void onNotificationBatchPosted(List<CoalescedEvent> events) {
+ NotifCollection.this.onNotificationGroupPosted(events);
+ }
+
+ @Override
public void onNotificationRemoved(StatusBarNotification sbn, RankingMap rankingMap) {
NotifCollection.this.onNotificationRemoved(sbn, rankingMap, REASON_UNKNOWN);
}
diff --git a/packages/SystemUI/src/com/android/systemui/statusbar/notification/collection/init/NewNotifPipeline.java b/packages/SystemUI/src/com/android/systemui/statusbar/notification/collection/init/NewNotifPipeline.java
index 5fc55da..5e0bd4f 100644
--- a/packages/SystemUI/src/com/android/systemui/statusbar/notification/collection/init/NewNotifPipeline.java
+++ b/packages/SystemUI/src/com/android/systemui/statusbar/notification/collection/init/NewNotifPipeline.java
@@ -24,6 +24,7 @@
import com.android.systemui.statusbar.notification.collection.NotifCollection;
import com.android.systemui.statusbar.notification.collection.NotifListBuilderImpl;
import com.android.systemui.statusbar.notification.collection.coordinator.NotifCoordinators;
+import com.android.systemui.statusbar.notification.collection.notifcollection.GroupCoalescer;
import java.io.FileDescriptor;
import java.io.PrintWriter;
@@ -36,6 +37,7 @@
*/
@Singleton
public class NewNotifPipeline implements Dumpable {
+ private final GroupCoalescer mGroupCoalescer;
private final NotifCollection mNotifCollection;
private final NotifListBuilderImpl mNotifPipeline;
private final NotifCoordinators mNotifPluggableCoordinators;
@@ -45,10 +47,12 @@
@Inject
public NewNotifPipeline(
+ GroupCoalescer groupCoalescer,
NotifCollection notifCollection,
NotifListBuilderImpl notifPipeline,
NotifCoordinators notifCoordinators,
DumpController dumpController) {
+ mGroupCoalescer = groupCoalescer;
mNotifCollection = notifCollection;
mNotifPipeline = notifPipeline;
mNotifPluggableCoordinators = notifCoordinators;
@@ -58,20 +62,26 @@
/** Hooks the new pipeline up to NotificationManager */
public void initialize(
NotificationListener notificationService) {
- mFakePipelineConsumer.attach(mNotifPipeline);
- mNotifPipeline.attach(mNotifCollection);
- mNotifCollection.attach(notificationService);
- mNotifPluggableCoordinators.attach(mNotifCollection, mNotifPipeline);
-
- Log.d(TAG, "Notif pipeline initialized");
mDumpController.registerDumpable("NotifPipeline", this);
+
+ // Wire up coordinators
+ mFakePipelineConsumer.attach(mNotifPipeline);
+ mNotifPluggableCoordinators.attach(mNotifCollection, mNotifPipeline);
+
+ // Wire up pipeline
+ mNotifPipeline.attach(mNotifCollection);
+ mNotifCollection.attach(mGroupCoalescer);
+ mGroupCoalescer.attach(notificationService);
+
+ Log.d(TAG, "Notif pipeline initialized");
}
@Override
public void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
mFakePipelineConsumer.dump(fd, pw, args);
mNotifPluggableCoordinators.dump(fd, pw, args);
+ mGroupCoalescer.dump(fd, pw, args);
}
private static final String TAG = "NewNotifPipeline";
diff --git a/packages/SystemUI/src/com/android/systemui/statusbar/notification/collection/notifcollection/CoalescedEvent.kt b/packages/SystemUI/src/com/android/systemui/statusbar/notification/collection/notifcollection/CoalescedEvent.kt
new file mode 100644
index 0000000..b6218b4
--- /dev/null
+++ b/packages/SystemUI/src/com/android/systemui/statusbar/notification/collection/notifcollection/CoalescedEvent.kt
@@ -0,0 +1,32 @@
+/*
+ * Copyright (C) 2019 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.systemui.statusbar.notification.collection.notifcollection
+
+import android.service.notification.NotificationListenerService.Ranking
+import android.service.notification.StatusBarNotification
+
+data class CoalescedEvent(
+ val key: String,
+ var position: Int,
+ var sbn: StatusBarNotification,
+ var ranking: Ranking,
+ var batch: EventBatch?
+) {
+ override fun toString(): String {
+ return "CoalescedEvent(key=$key)"
+ }
+}
diff --git a/packages/SystemUI/src/com/android/systemui/statusbar/notification/collection/notifcollection/EventBatch.java b/packages/SystemUI/src/com/android/systemui/statusbar/notification/collection/notifcollection/EventBatch.java
new file mode 100644
index 0000000..ac51178
--- /dev/null
+++ b/packages/SystemUI/src/com/android/systemui/statusbar/notification/collection/notifcollection/EventBatch.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2019 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.systemui.statusbar.notification.collection.notifcollection;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Represents a set of notification post events for a particular notification group.
+ */
+public class EventBatch {
+ /** SystemClock.uptimeMillis() */
+ final long mCreatedTimestamp;
+
+ /** SBN.getGroupKey -- same for all members */
+ final String mGroupKey;
+
+ /**
+ * All members of the batch. Must share the same group key. Includes both children and
+ * summaries.
+ */
+ final List<CoalescedEvent> mMembers = new ArrayList<>();
+
+ EventBatch(long createdTimestamp, String groupKey) {
+ mCreatedTimestamp = createdTimestamp;
+ this.mGroupKey = groupKey;
+ }
+}
diff --git a/packages/SystemUI/src/com/android/systemui/statusbar/notification/collection/notifcollection/GroupCoalescer.java b/packages/SystemUI/src/com/android/systemui/statusbar/notification/collection/notifcollection/GroupCoalescer.java
new file mode 100644
index 0000000..069c15f
--- /dev/null
+++ b/packages/SystemUI/src/com/android/systemui/statusbar/notification/collection/notifcollection/GroupCoalescer.java
@@ -0,0 +1,303 @@
+/*
+ * Copyright (C) 2019 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.systemui.statusbar.notification.collection.notifcollection;
+
+import static com.android.systemui.statusbar.notification.logging.NotifEvent.COALESCED_EVENT;
+import static com.android.systemui.statusbar.notification.logging.NotifEvent.EARLY_BATCH_EMIT;
+import static com.android.systemui.statusbar.notification.logging.NotifEvent.EMIT_EVENT_BATCH;
+
+import static java.util.Objects.requireNonNull;
+
+import android.annotation.MainThread;
+import android.service.notification.NotificationListenerService.Ranking;
+import android.service.notification.NotificationListenerService.RankingMap;
+import android.service.notification.StatusBarNotification;
+import android.util.ArrayMap;
+
+import androidx.annotation.NonNull;
+
+import com.android.systemui.Dumpable;
+import com.android.systemui.dagger.qualifiers.Main;
+import com.android.systemui.statusbar.NotificationListener;
+import com.android.systemui.statusbar.NotificationListener.NotificationHandler;
+import com.android.systemui.statusbar.notification.logging.NotifLog;
+import com.android.systemui.util.concurrency.DelayableExecutor;
+import com.android.systemui.util.time.SystemClock;
+
+import java.io.FileDescriptor;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Map;
+
+import javax.inject.Inject;
+
+/**
+ * An attempt to make posting notification groups an atomic process
+ *
+ * Due to the nature of the groups API, individual members of a group are posted to system server
+ * one at a time. This means that whenever a group member is posted, we don't know if there are any
+ * more members soon to be posted.
+ *
+ * The Coalescer sits between the NotificationListenerService and the NotifCollection. It clusters
+ * new notifications that are members of groups and delays their posting until any of the following
+ * criteria are met:
+ *
+ * - A few milliseconds pass (see groupLingerDuration on the constructor)
+ * - Any notification in the delayed group is updated
+ * - Any notification in the delayed group is retracted
+ *
+ * Once we cross this threshold, all members of the group in question are posted atomically to the
+ * NotifCollection. If this process was triggered by an update or removal, then that event is then
+ * passed along to the NotifCollection.
+ */
+@MainThread
+public class GroupCoalescer implements Dumpable {
+ private final DelayableExecutor mMainExecutor;
+ private final SystemClock mClock;
+ private final NotifLog mLog;
+ private final long mGroupLingerDuration;
+
+ private BatchableNotificationHandler mHandler;
+
+ private final Map<String, CoalescedEvent> mCoalescedEvents = new ArrayMap<>();
+ private final Map<String, EventBatch> mBatches = new ArrayMap<>();
+
+ @Inject
+ public GroupCoalescer(
+ @Main DelayableExecutor mainExecutor,
+ SystemClock clock, NotifLog log) {
+ this(mainExecutor, clock, log, GROUP_LINGER_DURATION);
+ }
+
+ /**
+ * @param groupLingerDuration How long, in ms, that notifications that are members of a group
+ * are delayed within the GroupCoalescer before being posted
+ */
+ GroupCoalescer(
+ @Main DelayableExecutor mainExecutor,
+ SystemClock clock,
+ NotifLog log,
+ long groupLingerDuration) {
+ mMainExecutor = mainExecutor;
+ mClock = clock;
+ mLog = log;
+ mGroupLingerDuration = groupLingerDuration;
+ }
+
+ /**
+ * Attaches the coalescer to the pipeline, making it ready to receive events. Should only be
+ * called once.
+ */
+ public void attach(NotificationListener listenerService) {
+ listenerService.addNotificationHandler(mListener);
+ }
+
+ public void setNotificationHandler(BatchableNotificationHandler handler) {
+ mHandler = handler;
+ }
+
+ private final NotificationHandler mListener = new NotificationHandler() {
+ @Override
+ public void onNotificationPosted(StatusBarNotification sbn, RankingMap rankingMap) {
+ maybeEmitBatch(sbn.getKey());
+ applyRanking(rankingMap);
+
+ final boolean shouldCoalesce = handleNotificationPosted(sbn, rankingMap);
+
+ if (shouldCoalesce) {
+ mLog.log(COALESCED_EVENT, String.format("Coalesced notification %s", sbn.getKey()));
+ mHandler.onNotificationRankingUpdate(rankingMap);
+ } else {
+ mHandler.onNotificationPosted(sbn, rankingMap);
+ }
+ }
+
+ @Override
+ public void onNotificationRemoved(StatusBarNotification sbn, RankingMap rankingMap) {
+ maybeEmitBatch(sbn.getKey());
+ applyRanking(rankingMap);
+ mHandler.onNotificationRemoved(sbn, rankingMap);
+ }
+
+ @Override
+ public void onNotificationRemoved(
+ StatusBarNotification sbn,
+ RankingMap rankingMap,
+ int reason) {
+ maybeEmitBatch(sbn.getKey());
+ applyRanking(rankingMap);
+ mHandler.onNotificationRemoved(sbn, rankingMap, reason);
+ }
+
+ @Override
+ public void onNotificationRankingUpdate(RankingMap rankingMap) {
+ applyRanking(rankingMap);
+ mHandler.onNotificationRankingUpdate(rankingMap);
+ }
+ };
+
+ private void maybeEmitBatch(String memberKey) {
+ CoalescedEvent event = mCoalescedEvents.get(memberKey);
+ if (event != null) {
+ mLog.log(EARLY_BATCH_EMIT,
+ String.format("Modification of %s triggered early emit of batched group %s",
+ memberKey, requireNonNull(event.getBatch()).mGroupKey));
+ emitBatch(requireNonNull(event.getBatch()));
+ }
+ }
+
+ /**
+ * @return True if the notification was coalesced and false otherwise.
+ */
+ private boolean handleNotificationPosted(
+ StatusBarNotification sbn,
+ RankingMap rankingMap) {
+
+ if (mCoalescedEvents.containsKey(sbn.getKey())) {
+ throw new IllegalStateException(
+ "Notification has already been coalesced: " + sbn.getKey());
+ }
+
+ if (sbn.isGroup()) {
+ EventBatch batch = startBatchingGroup(sbn.getGroupKey());
+ CoalescedEvent event =
+ new CoalescedEvent(
+ sbn.getKey(),
+ batch.mMembers.size(),
+ sbn,
+ requireRanking(rankingMap, sbn.getKey()),
+ batch);
+
+ batch.mMembers.add(event);
+
+ mCoalescedEvents.put(event.getKey(), event);
+
+ return true;
+ } else {
+ return false;
+ }
+ }
+
+ private EventBatch startBatchingGroup(final String groupKey) {
+ EventBatch batch = mBatches.get(groupKey);
+ if (batch == null) {
+ final EventBatch newBatch = new EventBatch(mClock.uptimeMillis(), groupKey);
+ mBatches.put(groupKey, newBatch);
+ mMainExecutor.executeDelayed(() -> emitBatch(newBatch), mGroupLingerDuration);
+
+ batch = newBatch;
+ }
+ return batch;
+ }
+
+ private void emitBatch(EventBatch batch) {
+ if (batch != mBatches.get(batch.mGroupKey)) {
+ // If we emit a batch early, we don't want to emit it a second time when its timeout
+ // expires.
+ return;
+ }
+ if (batch.mMembers.isEmpty()) {
+ throw new IllegalStateException("Batch " + batch.mGroupKey + " cannot be empty");
+ }
+
+ mBatches.remove(batch.mGroupKey);
+
+ final List<CoalescedEvent> events = new ArrayList<>(batch.mMembers);
+ for (CoalescedEvent event : events) {
+ mCoalescedEvents.remove(event.getKey());
+ event.setBatch(null);
+ }
+ events.sort(mEventComparator);
+
+ mLog.log(EMIT_EVENT_BATCH, "Emitting event batch for group " + batch.mGroupKey);
+
+ mHandler.onNotificationBatchPosted(events);
+ }
+
+ private Ranking requireRanking(RankingMap rankingMap, String key) {
+ Ranking ranking = new Ranking();
+ if (!rankingMap.getRanking(key, ranking)) {
+ throw new IllegalArgumentException("Ranking map does not contain key " + key);
+ }
+ return ranking;
+ }
+
+ private void applyRanking(RankingMap rankingMap) {
+ for (CoalescedEvent event : mCoalescedEvents.values()) {
+ Ranking ranking = new Ranking();
+ if (!rankingMap.getRanking(event.getKey(), ranking)) {
+ throw new IllegalStateException(
+ "Ranking map doesn't contain key: " + event.getKey());
+ }
+ event.setRanking(ranking);
+ }
+ }
+
+ @Override
+ public void dump(@NonNull FileDescriptor fd, @NonNull PrintWriter pw, @NonNull String[] args) {
+ long now = mClock.uptimeMillis();
+
+ int eventCount = 0;
+
+ pw.println();
+ pw.println("Coalesced notifications:");
+ for (EventBatch batch : mBatches.values()) {
+ pw.println(" Batch " + batch.mGroupKey + ":");
+ pw.println(" Created" + (now - batch.mCreatedTimestamp) + "ms ago");
+ for (CoalescedEvent event : batch.mMembers) {
+ pw.println(" " + event.getKey());
+ eventCount++;
+ }
+ }
+
+ if (eventCount != mCoalescedEvents.size()) {
+ pw.println(" ERROR: batches contain " + mCoalescedEvents.size() + " events but"
+ + " am tracking " + mCoalescedEvents.size() + " total events");
+ pw.println(" All tracked events:");
+ for (CoalescedEvent event : mCoalescedEvents.values()) {
+ pw.println(" " + event.getKey());
+ }
+ }
+ }
+
+ private final Comparator<CoalescedEvent> mEventComparator = (o1, o2) -> {
+ int cmp = Boolean.compare(
+ o2.getSbn().getNotification().isGroupSummary(),
+ o1.getSbn().getNotification().isGroupSummary());
+ if (cmp == 0) {
+ cmp = o1.getPosition() - o2.getPosition();
+ }
+ return cmp;
+ };
+
+ /**
+ * Extension of {@link NotificationListener.NotificationHandler} to include notification
+ * groups.
+ */
+ public interface BatchableNotificationHandler extends NotificationHandler {
+ /**
+ * Fired whenever the coalescer needs to emit a batch of multiple post events. This is
+ * usually the addition of a new group, but can contain just a single event, or just an
+ * update to a subset of an existing group.
+ */
+ void onNotificationBatchPosted(List<CoalescedEvent> events);
+ }
+
+ private static final int GROUP_LINGER_DURATION = 40;
+}
diff --git a/packages/SystemUI/src/com/android/systemui/statusbar/notification/logging/NotifEvent.java b/packages/SystemUI/src/com/android/systemui/statusbar/notification/logging/NotifEvent.java
index c18af80..e4a57d7 100644
--- a/packages/SystemUI/src/com/android/systemui/statusbar/notification/logging/NotifEvent.java
+++ b/packages/SystemUI/src/com/android/systemui/statusbar/notification/logging/NotifEvent.java
@@ -23,6 +23,7 @@
import com.android.systemui.log.RichEvent;
import com.android.systemui.statusbar.notification.NotificationEntryManager;
import com.android.systemui.statusbar.notification.collection.listbuilder.NotifListBuilder;
+import com.android.systemui.statusbar.notification.collection.notifcollection.GroupCoalescer;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
@@ -58,7 +59,10 @@
*/
@Override
public String[] getEventLabels() {
- assert (TOTAL_EVENT_LABELS == (TOTAL_NEM_EVENT_TYPES + TOTAL_LIST_BUILDER_EVENT_TYPES));
+ assert (TOTAL_EVENT_LABELS
+ == (TOTAL_NEM_EVENT_TYPES
+ + TOTAL_LIST_BUILDER_EVENT_TYPES
+ + TOTAL_COALESCER_EVENT_TYPES));
return EVENT_LABELS;
}
@@ -141,7 +145,10 @@
"LifetimeExtended",
"RemoveIntercepted",
"InflationAborted",
- "Inflated"
+ "Inflated",
+
+ "CoalescedEvent",
+ "EarlyBatchEmit"
};
private static final int TOTAL_EVENT_LABELS = EVENT_LABELS.length;
@@ -167,7 +174,7 @@
/**
* Events related to {@link NotificationEntryManager}
*/
- public static final int NOTIF_ADDED = TOTAL_LIST_BUILDER_EVENT_TYPES + 0;
+ public static final int NOTIF_ADDED = TOTAL_LIST_BUILDER_EVENT_TYPES;
public static final int NOTIF_REMOVED = TOTAL_LIST_BUILDER_EVENT_TYPES + 1;
public static final int NOTIF_UPDATED = TOTAL_LIST_BUILDER_EVENT_TYPES + 2;
public static final int FILTER = TOTAL_LIST_BUILDER_EVENT_TYPES + 3;
@@ -180,4 +187,12 @@
public static final int INFLATION_ABORTED = TOTAL_LIST_BUILDER_EVENT_TYPES + 9;
public static final int INFLATED = TOTAL_LIST_BUILDER_EVENT_TYPES + 10;
private static final int TOTAL_NEM_EVENT_TYPES = 11;
+
+ /**
+ * Events related to {@link GroupCoalescer}
+ */
+ public static final int COALESCED_EVENT = TOTAL_NEM_EVENT_TYPES;
+ public static final int EARLY_BATCH_EMIT = TOTAL_NEM_EVENT_TYPES + 1;
+ public static final int EMIT_EVENT_BATCH = TOTAL_NEM_EVENT_TYPES + 2;
+ private static final int TOTAL_COALESCER_EVENT_TYPES = 2;
}
diff --git a/packages/SystemUI/tests/src/com/android/systemui/statusbar/notification/collection/NotifCollectionTest.java b/packages/SystemUI/tests/src/com/android/systemui/statusbar/notification/collection/NotifCollectionTest.java
index 128fc1f..0837a42 100644
--- a/packages/SystemUI/tests/src/com/android/systemui/statusbar/notification/collection/NotifCollectionTest.java
+++ b/packages/SystemUI/tests/src/com/android/systemui/statusbar/notification/collection/NotifCollectionTest.java
@@ -29,6 +29,7 @@
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.clearInvocations;
import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static java.util.Objects.requireNonNull;
@@ -40,17 +41,19 @@
import android.testing.AndroidTestingRunner;
import android.testing.TestableLooper;
import android.util.ArrayMap;
+import android.util.ArraySet;
import androidx.test.filters.SmallTest;
import com.android.internal.statusbar.IStatusBarService;
import com.android.internal.statusbar.NotificationVisibility;
import com.android.systemui.SysuiTestCase;
-import com.android.systemui.statusbar.NotificationListener;
-import com.android.systemui.statusbar.NotificationListener.NotificationHandler;
import com.android.systemui.statusbar.RankingBuilder;
import com.android.systemui.statusbar.notification.collection.NoManSimulator.NotifEvent;
import com.android.systemui.statusbar.notification.collection.NotifCollection.CancellationReason;
+import com.android.systemui.statusbar.notification.collection.notifcollection.CoalescedEvent;
+import com.android.systemui.statusbar.notification.collection.notifcollection.GroupCoalescer;
+import com.android.systemui.statusbar.notification.collection.notifcollection.GroupCoalescer.BatchableNotificationHandler;
import com.android.systemui.util.Assert;
import org.junit.Before;
@@ -63,6 +66,8 @@
import org.mockito.Spy;
import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
import java.util.Map;
@SmallTest
@@ -71,18 +76,20 @@
public class NotifCollectionTest extends SysuiTestCase {
@Mock private IStatusBarService mStatusBarService;
- @Mock private NotificationListener mListenerService;
+ @Mock private GroupCoalescer mGroupCoalescer;
@Spy private RecordingCollectionListener mCollectionListener;
+ @Mock private CollectionReadyForBuildListener mBuildListener;
@Spy private RecordingLifetimeExtender mExtender1 = new RecordingLifetimeExtender("Extender1");
@Spy private RecordingLifetimeExtender mExtender2 = new RecordingLifetimeExtender("Extender2");
@Spy private RecordingLifetimeExtender mExtender3 = new RecordingLifetimeExtender("Extender3");
- @Captor private ArgumentCaptor<NotificationHandler> mListenerCaptor;
+ @Captor private ArgumentCaptor<BatchableNotificationHandler> mListenerCaptor;
@Captor private ArgumentCaptor<NotificationEntry> mEntryCaptor;
+ @Captor private ArgumentCaptor<Collection<NotificationEntry>> mBuildListCaptor;
private NotifCollection mCollection;
- private NotificationHandler mNotificationHandler;
+ private BatchableNotificationHandler mNotifHandler;
private NoManSimulator mNoMan;
@@ -92,16 +99,17 @@
Assert.sMainLooper = TestableLooper.get(this).getLooper();
mCollection = new NotifCollection(mStatusBarService);
- mCollection.attach(mListenerService);
+ mCollection.attach(mGroupCoalescer);
mCollection.addCollectionListener(mCollectionListener);
+ mCollection.setBuildListener(mBuildListener);
// Capture the listener object that the collection registers with the listener service so
// we can simulate listener service events in tests below
- verify(mListenerService).addNotificationHandler(mListenerCaptor.capture());
- mNotificationHandler = requireNonNull(mListenerCaptor.getValue());
+ verify(mGroupCoalescer).setNotificationHandler(mListenerCaptor.capture());
+ mNotifHandler = requireNonNull(mListenerCaptor.getValue());
mNoMan = new NoManSimulator();
- mNoMan.addListener(mNotificationHandler);
+ mNoMan.addListener(mNotifHandler);
}
@Test
@@ -121,6 +129,61 @@
}
@Test
+ public void testEventDispatchedWhenNotifBatchPosted() {
+ // GIVEN a NotifCollection with one notif already posted
+ mNoMan.postNotif(buildNotif(TEST_PACKAGE, 2)
+ .setGroup(mContext, "group_1")
+ .setContentTitle(mContext, "Old version"));
+
+ clearInvocations(mCollectionListener);
+ clearInvocations(mBuildListener);
+
+ // WHEN three notifications from the same group are posted (one of them an update, two of
+ // them new)
+ NotificationEntry entry1 = buildNotif(TEST_PACKAGE, 1)
+ .setGroup(mContext, "group_1")
+ .build();
+ NotificationEntry entry2 = buildNotif(TEST_PACKAGE, 2)
+ .setGroup(mContext, "group_1")
+ .setContentTitle(mContext, "New version")
+ .build();
+ NotificationEntry entry3 = buildNotif(TEST_PACKAGE, 3)
+ .setGroup(mContext, "group_1")
+ .build();
+
+ mNotifHandler.onNotificationBatchPosted(Arrays.asList(
+ new CoalescedEvent(entry1.getKey(), 0, entry1.getSbn(), entry1.getRanking(), null),
+ new CoalescedEvent(entry2.getKey(), 1, entry2.getSbn(), entry2.getRanking(), null),
+ new CoalescedEvent(entry3.getKey(), 2, entry3.getSbn(), entry3.getRanking(), null)
+ ));
+
+ // THEN onEntryAdded is called on the new ones
+ verify(mCollectionListener, times(2)).onEntryAdded(mEntryCaptor.capture());
+
+ List<NotificationEntry> capturedAdds = mEntryCaptor.getAllValues();
+
+ assertEquals(entry1.getSbn(), capturedAdds.get(0).getSbn());
+ assertEquals(entry1.getRanking(), capturedAdds.get(0).getRanking());
+
+ assertEquals(entry3.getSbn(), capturedAdds.get(1).getSbn());
+ assertEquals(entry3.getRanking(), capturedAdds.get(1).getRanking());
+
+ // THEN onEntryUpdated is called on the middle one
+ verify(mCollectionListener).onEntryUpdated(mEntryCaptor.capture());
+ NotificationEntry capturedUpdate = mEntryCaptor.getValue();
+ assertEquals(entry2.getSbn(), capturedUpdate.getSbn());
+ assertEquals(entry2.getRanking(), capturedUpdate.getRanking());
+
+ // THEN onBuildList is called only once
+ verify(mBuildListener).onBuildList(mBuildListCaptor.capture());
+ assertEquals(new ArraySet<>(Arrays.asList(
+ capturedAdds.get(0),
+ capturedAdds.get(1),
+ capturedUpdate
+ )), new ArraySet<>(mBuildListCaptor.getValue()));
+ }
+
+ @Test
public void testEventDispatchedWhenNotifUpdated() {
// GIVEN a collection with one notif
mNoMan.postNotif(buildNotif(TEST_PACKAGE, 3)
diff --git a/packages/SystemUI/tests/src/com/android/systemui/statusbar/notification/collection/notifcollection/GroupCoalescerTest.java b/packages/SystemUI/tests/src/com/android/systemui/statusbar/notification/collection/notifcollection/GroupCoalescerTest.java
new file mode 100644
index 0000000..7ff3240
--- /dev/null
+++ b/packages/SystemUI/tests/src/com/android/systemui/statusbar/notification/collection/notifcollection/GroupCoalescerTest.java
@@ -0,0 +1,323 @@
+/*
+ * Copyright (C) 2019 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.systemui.statusbar.notification.collection.notifcollection;
+
+import static com.android.internal.util.Preconditions.checkNotNull;
+
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyList;
+import static org.mockito.Mockito.clearInvocations;
+import static org.mockito.Mockito.inOrder;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+
+import android.service.notification.NotificationListenerService.Ranking;
+import android.service.notification.NotificationListenerService.RankingMap;
+import android.service.notification.StatusBarNotification;
+import android.testing.AndroidTestingRunner;
+
+import androidx.test.filters.SmallTest;
+
+import com.android.systemui.SysuiTestCase;
+import com.android.systemui.statusbar.NotificationListener;
+import com.android.systemui.statusbar.NotificationListener.NotificationHandler;
+import com.android.systemui.statusbar.RankingBuilder;
+import com.android.systemui.statusbar.notification.collection.NoManSimulator;
+import com.android.systemui.statusbar.notification.collection.NoManSimulator.NotifEvent;
+import com.android.systemui.statusbar.notification.collection.NotificationEntryBuilder;
+import com.android.systemui.statusbar.notification.logging.NotifLog;
+import com.android.systemui.util.concurrency.FakeExecutor;
+import com.android.systemui.util.time.FakeSystemClock;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
+import org.mockito.InOrder;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+
+import java.util.Arrays;
+import java.util.Collections;
+
+@SmallTest
+@RunWith(AndroidTestingRunner.class)
+public class GroupCoalescerTest extends SysuiTestCase {
+
+ private GroupCoalescer mCoalescer;
+
+ @Mock private NotificationListener mListenerService;
+ @Mock private GroupCoalescer.BatchableNotificationHandler mListener;
+ @Mock private NotifLog mLog;
+
+ @Captor private ArgumentCaptor<NotificationHandler> mListenerCaptor;
+
+ private final NoManSimulator mNoMan = new NoManSimulator();
+ private final FakeSystemClock mClock = new FakeSystemClock();
+ private final FakeExecutor mExecutor = new FakeExecutor(mClock);
+
+ @Before
+ public void setUp() {
+ MockitoAnnotations.initMocks(this);
+
+ mCoalescer =
+ new GroupCoalescer(
+ mExecutor,
+ mClock,
+ mLog,
+ LINGER_DURATION);
+ mCoalescer.setNotificationHandler(mListener);
+ mCoalescer.attach(mListenerService);
+
+ verify(mListenerService).addNotificationHandler(mListenerCaptor.capture());
+ NotificationHandler serviceListener = checkNotNull(mListenerCaptor.getValue());
+ mNoMan.addListener(serviceListener);
+ }
+
+ @Test
+ public void testUngroupedNotificationsAreNotCoalesced() {
+ // WHEN a notification that doesn't have a group key is posted
+ NotifEvent notif1 = mNoMan.postNotif(
+ new NotificationEntryBuilder()
+ .setId(0)
+ .setPkg(TEST_PACKAGE_A));
+ mClock.advanceTime(LINGER_DURATION);
+
+ // THEN the event is passed through to the handler
+ verify(mListener).onNotificationPosted(notif1.sbn, notif1.rankingMap);
+
+ // Then the event isn't emitted in a batch
+ verify(mListener, never()).onNotificationBatchPosted(anyList());
+ }
+
+ @Test
+ public void testGroupedNotificationsAreCoalesced() {
+ // WHEN a notification that has a group key is posted
+ NotifEvent notif1 = mNoMan.postNotif(
+ new NotificationEntryBuilder()
+ .setId(0)
+ .setPkg(TEST_PACKAGE_A)
+ .setGroup(mContext, GROUP_1));
+
+ // THEN the event is not passed on to the handler
+ verify(mListener, never()).onNotificationPosted(
+ any(StatusBarNotification.class),
+ any(RankingMap.class));
+
+ // Then the event isn't (yet) emitted in a batch
+ verify(mListener, never()).onNotificationBatchPosted(anyList());
+ }
+
+ @Test
+ public void testCoalescedNotificationsStillPassThroughRankingUpdate() {
+ // WHEN a notification that has a group key is posted
+ NotifEvent notif1 = mNoMan.postNotif(
+ new NotificationEntryBuilder()
+ .setId(0)
+ .setPkg(TEST_PACKAGE_A)
+ .setGroup(mContext, GROUP_1));
+
+ // THEN the listener receives a ranking update instead of an add
+ verify(mListener).onNotificationRankingUpdate(notif1.rankingMap);
+ }
+
+ @Test
+ public void testCoalescedNotificationsArePosted() {
+ // GIVEN three notifs are posted that are part of the same group
+ NotifEvent notif1 = mNoMan.postNotif(new NotificationEntryBuilder()
+ .setPkg(TEST_PACKAGE_A)
+ .setId(1)
+ .setGroup(mContext, GROUP_1));
+
+ NotifEvent notif2 = mNoMan.postNotif(new NotificationEntryBuilder()
+ .setPkg(TEST_PACKAGE_A)
+ .setId(2)
+ .setGroup(mContext, GROUP_1)
+ .setGroupSummary(mContext, true));
+
+ NotifEvent notif3 = mNoMan.postNotif(new NotificationEntryBuilder()
+ .setPkg(TEST_PACKAGE_A)
+ .setId(3)
+ .setGroup(mContext, GROUP_1));
+
+ verify(mListener, never()).onNotificationPosted(
+ any(StatusBarNotification.class),
+ any(RankingMap.class));
+ verify(mListener, never()).onNotificationBatchPosted(anyList());
+
+ // WHEN enough time passes
+ mClock.advanceTime(LINGER_DURATION);
+
+ // THEN the coalesced notifs are applied. The summary is sorted to the front.
+ verify(mListener).onNotificationBatchPosted(Arrays.asList(
+ new CoalescedEvent(notif2.key, 1, notif2.sbn, notif2.ranking, null),
+ new CoalescedEvent(notif1.key, 0, notif1.sbn, notif1.ranking, null),
+ new CoalescedEvent(notif3.key, 2, notif3.sbn, notif3.ranking, null)
+ ));
+ }
+
+ @Test
+ public void testCoalescedEventsThatAreLaterUngroupedAreEmittedImmediatelyAndNotLater() {
+ // GIVEN a few newly posted notifications in the same group
+ NotifEvent notif1a = mNoMan.postNotif(new NotificationEntryBuilder()
+ .setPkg(TEST_PACKAGE_A)
+ .setId(1)
+ .setContentTitle(mContext, "Grouped message")
+ .setGroup(mContext, GROUP_1));
+ NotifEvent notif2 = mNoMan.postNotif(new NotificationEntryBuilder()
+ .setPkg(TEST_PACKAGE_A)
+ .setId(2)
+ .setGroup(mContext, GROUP_1));
+ NotifEvent notif3 = mNoMan.postNotif(new NotificationEntryBuilder()
+ .setPkg(TEST_PACKAGE_A)
+ .setId(3)
+ .setGroup(mContext, GROUP_1));
+
+ verify(mListener, never()).onNotificationPosted(
+ any(StatusBarNotification.class),
+ any(RankingMap.class));
+ verify(mListener, never()).onNotificationBatchPosted(anyList());
+
+ // WHEN one of them is updated to no longer be in the group
+ NotifEvent notif1b = mNoMan.postNotif(new NotificationEntryBuilder()
+ .setPkg(TEST_PACKAGE_A)
+ .setId(1)
+ .setContentTitle(mContext, "Oops no longer grouped"));
+
+ // THEN the pre-existing batch is first emitted
+ InOrder inOrder = inOrder(mListener);
+ inOrder.verify(mListener).onNotificationBatchPosted(Arrays.asList(
+ new CoalescedEvent(notif1a.key, 0, notif1a.sbn, notif1a.ranking, null),
+ new CoalescedEvent(notif2.key, 1, notif2.sbn, notif2.ranking, null),
+ new CoalescedEvent(notif3.key, 2, notif3.sbn, notif3.ranking, null)
+ ));
+
+ // THEN the updated notif is emitted
+ inOrder.verify(mListener).onNotificationPosted(notif1b.sbn, notif1b.rankingMap);
+
+ // WHEN the time runs out on the remainder of the group
+ clearInvocations(mListener);
+ mClock.advanceTime(LINGER_DURATION);
+
+ // THEN no lingering batch is applied
+ verify(mListener, never()).onNotificationBatchPosted(anyList());
+ }
+
+ @Test
+ public void testUpdatingCoalescedNotifTriggersBatchEmit() {
+ // GIVEN two grouped, coalesced notifications
+ NotifEvent notif1 = mNoMan.postNotif(new NotificationEntryBuilder()
+ .setPkg(TEST_PACKAGE_A)
+ .setId(1)
+ .setGroup(mContext, GROUP_1));
+ NotifEvent notif2a = mNoMan.postNotif(new NotificationEntryBuilder()
+ .setPkg(TEST_PACKAGE_A)
+ .setId(2)
+ .setContentTitle(mContext, "Version 1")
+ .setGroup(mContext, GROUP_1));
+
+ // WHEN one of them gets updated
+ NotifEvent notif2b = mNoMan.postNotif(new NotificationEntryBuilder()
+ .setPkg(TEST_PACKAGE_A)
+ .setId(2)
+ .setContentTitle(mContext, "Version 2")
+ .setGroup(mContext, GROUP_1));
+
+ // THEN first, the coalesced group is emitted
+ verify(mListener).onNotificationBatchPosted(Arrays.asList(
+ new CoalescedEvent(notif1.key, 0, notif1.sbn, notif1.ranking, null),
+ new CoalescedEvent(notif2a.key, 1, notif2a.sbn, notif2a.ranking, null)
+ ));
+ verify(mListener, never()).onNotificationPosted(
+ any(StatusBarNotification.class),
+ any(RankingMap.class));
+
+ // THEN second, the update is emitted
+ mClock.advanceTime(LINGER_DURATION);
+ verify(mListener).onNotificationBatchPosted(Collections.singletonList(
+ new CoalescedEvent(notif2b.key, 0, notif2b.sbn, notif2b.ranking, null)
+ ));
+ }
+
+ @Test
+ public void testRemovingCoalescedNotifTriggersBatchEmit() {
+ // GIVEN two grouped, coalesced notifications
+ NotifEvent notif1 = mNoMan.postNotif(new NotificationEntryBuilder()
+ .setPkg(TEST_PACKAGE_A)
+ .setId(1)
+ .setGroup(mContext, GROUP_1));
+ NotifEvent notif2a = mNoMan.postNotif(new NotificationEntryBuilder()
+ .setPkg(TEST_PACKAGE_A)
+ .setId(2)
+ .setGroup(mContext, GROUP_1));
+
+ // WHEN one of them gets retracted
+ NotifEvent notif2b = mNoMan.retractNotif(notif2a.sbn, 0);
+
+ // THEN first, the coalesced group is emitted
+ InOrder inOrder = inOrder(mListener);
+ inOrder.verify(mListener).onNotificationBatchPosted(Arrays.asList(
+ new CoalescedEvent(notif1.key, 0, notif1.sbn, notif1.ranking, null),
+ new CoalescedEvent(notif2a.key, 1, notif2a.sbn, notif2a.ranking, null)
+ ));
+
+ // THEN second, the removal is emitted
+ inOrder.verify(mListener).onNotificationRemoved(notif2b.sbn, notif2b.rankingMap, 0);
+ }
+
+ @Test
+ public void testRankingsAreUpdated() {
+ // GIVEN a couple coalesced notifications
+ NotifEvent notif1 = mNoMan.postNotif(new NotificationEntryBuilder()
+ .setPkg(TEST_PACKAGE_A)
+ .setId(1)
+ .setGroup(mContext, GROUP_1));
+ NotifEvent notif2 = mNoMan.postNotif(new NotificationEntryBuilder()
+ .setPkg(TEST_PACKAGE_A)
+ .setId(2)
+ .setGroup(mContext, GROUP_1));
+
+ // WHEN an update to an unrelated notification comes in that updates their rankings
+ Ranking ranking1b = new RankingBuilder()
+ .setKey(notif1.key)
+ .setLastAudiblyAlertedMs(4747)
+ .build();
+ Ranking ranking2b = new RankingBuilder()
+ .setKey(notif2.key)
+ .setLastAudiblyAlertedMs(3333)
+ .build();
+ mNoMan.setRanking(notif1.key, ranking1b);
+ mNoMan.setRanking(notif2.key, ranking2b);
+ mNoMan.postNotif(new NotificationEntryBuilder()
+ .setPkg(TEST_PACKAGE_B)
+ .setId(17));
+
+ // THEN they have the new rankings when they are eventually emitted
+ mClock.advanceTime(LINGER_DURATION);
+ verify(mListener).onNotificationBatchPosted(Arrays.asList(
+ new CoalescedEvent(notif1.key, 0, notif1.sbn, ranking1b, null),
+ new CoalescedEvent(notif2.key, 1, notif2.sbn, ranking2b, null)
+ ));
+ }
+
+ private static final long LINGER_DURATION = 4700;
+
+ private static final String TEST_PACKAGE_A = "com.test.package_a";
+ private static final String TEST_PACKAGE_B = "com.test.package_b";
+ private static final String GROUP_1 = "group_1";
+}