Merge changes from topic "anm-refactor" into main (d6027dae) · Commits · e / os / android_frameworks_base

packages/SystemUI/src/com/android/systemui/statusbar/AlertingNotificationManager.java

deleted100644 → 0

+0 −409

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2018 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;

		import android.annotation.NonNull;
		import android.annotation.Nullable;
		import android.util.ArrayMap;
		import android.util.ArraySet;
		import android.util.Log;
		import android.view.accessibility.AccessibilityEvent;

		import com.android.systemui.dagger.qualifiers.Main;
		import com.android.systemui.statusbar.notification.collection.NotificationEntry;
		import com.android.systemui.statusbar.notification.row.NotificationRowContentBinder.InflationFlag;
		import com.android.systemui.statusbar.policy.HeadsUpManagerLogger;
		import com.android.systemui.util.concurrency.DelayableExecutor;
		import com.android.systemui.util.time.SystemClock;

		import java.util.stream.Stream;

		/**
		* A manager which contains notification alerting functionality, providing methods to add and
		* remove notifications that appear on screen for a period of time and dismiss themselves at the
		* appropriate time. These include heads up notifications and ambient pulses.
		*/
		public abstract class AlertingNotificationManager {
		private static final String TAG = "AlertNotifManager";
		protected final SystemClock mSystemClock;
		protected final ArrayMap<String, AlertEntry> mAlertEntries = new ArrayMap<>();
		protected final HeadsUpManagerLogger mLogger;

		protected int mMinimumDisplayTime;
		protected int mStickyForSomeTimeAutoDismissTime;
		protected int mAutoDismissTime;
		private DelayableExecutor mExecutor;

		public AlertingNotificationManager(HeadsUpManagerLogger logger,
		SystemClock systemClock, @Main DelayableExecutor executor) {
		mLogger = logger;
		mExecutor = executor;
		mSystemClock = systemClock;
		}

		/**
		* Called when posting a new notification that should alert the user and appear on screen.
		* Adds the notification to be managed.
		* @param entry entry to show
		*/
		public void showNotification(@NonNull NotificationEntry entry) {
		mLogger.logShowNotification(entry);
		addAlertEntry(entry);
		updateNotification(entry.getKey(), true /* alert */);
		entry.setInterruption();
		}

		/**
		* Try to remove the notification. May not succeed if the notification has not been shown long
		* enough and needs to be kept around.
		* @param key the key of the notification to remove
		* @param releaseImmediately force a remove regardless of earliest removal time
		* @return true if notification is removed, false otherwise
		*/
		public boolean removeNotification(@NonNull String key, boolean releaseImmediately) {
		mLogger.logRemoveNotification(key, releaseImmediately);
		AlertEntry alertEntry = mAlertEntries.get(key);
		if (alertEntry == null) {
		return true;
		}
		if (releaseImmediately \|\| canRemoveImmediately(key)) {
		removeAlertEntry(key);
		} else {
		alertEntry.removeAsSoonAsPossible();
		return false;
		}
		return true;
		}

		/**
		* Called when the notification state has been updated.
		* @param key the key of the entry that was updated
		* @param alert whether the notification should alert again and force reevaluation of
		* removal time
		*/
		public void updateNotification(@NonNull String key, boolean alert) {
		AlertEntry alertEntry = mAlertEntries.get(key);
		mLogger.logUpdateNotification(key, alert, alertEntry != null);
		if (alertEntry == null) {
		// the entry was released before this update (i.e by a listener) This can happen
		// with the groupmanager
		return;
		}

		alertEntry.mEntry.sendAccessibilityEvent(AccessibilityEvent.TYPE_WINDOW_CONTENT_CHANGED);
		if (alert) {
		alertEntry.updateEntry(true /* updatePostTime */, "updateNotification");
		}
		}

		/**
		* Clears all managed notifications.
		*/
		public void releaseAllImmediately() {
		mLogger.logReleaseAllImmediately();
		// A copy is necessary here as we are changing the underlying map. This would cause
		// undefined behavior if we iterated over the key set directly.
		ArraySet<String> keysToRemove = new ArraySet<>(mAlertEntries.keySet());
		for (String key : keysToRemove) {
		removeAlertEntry(key);
		}
		}

		/**
		* Returns the entry if it is managed by this manager.
		* @param key key of notification
		* @return the entry
		*/
		@Nullable
		public NotificationEntry getEntry(@NonNull String key) {
		AlertEntry entry = mAlertEntries.get(key);
		return entry != null ? entry.mEntry : null;
		}

		/**
		* Returns the stream of all current notifications managed by this manager.
		* @return all entries
		*/
		@NonNull
		public Stream<NotificationEntry> getAllEntries() {
		return mAlertEntries.values().stream().map(headsUpEntry -> headsUpEntry.mEntry);
		}

		/**
		* Whether or not there are any active alerting notifications.
		* @return true if there is an alert, false otherwise
		*/
		public boolean hasNotifications() {
		return !mAlertEntries.isEmpty();
		}

		/**
		* Whether or not the given notification is alerting and managed by this manager.
		* @return true if the notification is alerting
		*/
		public boolean isAlerting(@NonNull String key) {
		return mAlertEntries.containsKey(key);
		}

		/**
		* Gets the flag corresponding to the notification content view this alert manager will show.
		*
		* @return flag corresponding to the content view
		*/
		public abstract @InflationFlag int getContentFlag();

		/**
		* Add a new entry and begin managing it.
		* @param entry the entry to add
		*/
		protected final void addAlertEntry(@NonNull NotificationEntry entry) {
		AlertEntry alertEntry = createAlertEntry();
		alertEntry.setEntry(entry);
		mAlertEntries.put(entry.getKey(), alertEntry);
		onAlertEntryAdded(alertEntry);
		entry.sendAccessibilityEvent(AccessibilityEvent.TYPE_WINDOW_CONTENT_CHANGED);
		entry.setIsAlerting(true);
		}

		/**
		* Manager-specific logic that should occur when an entry is added.
		* @param alertEntry alert entry added
		*/
		protected abstract void onAlertEntryAdded(@NonNull AlertEntry alertEntry);

		/**
		* Remove a notification and reset the alert entry.
		* @param key key of notification to remove
		*/
		protected final void removeAlertEntry(@NonNull String key) {
		AlertEntry alertEntry = mAlertEntries.get(key);
		if (alertEntry == null) {
		return;
		}
		NotificationEntry entry = alertEntry.mEntry;

		// If the notification is animating, we will remove it at the end of the animation.
		if (entry != null && entry.isExpandAnimationRunning()) {
		return;
		}
		entry.demoteStickyHun();
		mAlertEntries.remove(key);
		onAlertEntryRemoved(alertEntry);
		entry.sendAccessibilityEvent(AccessibilityEvent.TYPE_WINDOW_CONTENT_CHANGED);
		alertEntry.reset();
		}

		/**
		* Manager-specific logic that should occur when an alert entry is removed.
		* @param alertEntry alert entry removed
		*/
		protected abstract void onAlertEntryRemoved(@NonNull AlertEntry alertEntry);

		/**
		* Returns a new alert entry instance.
		* @return a new AlertEntry
		*/
		protected AlertEntry createAlertEntry() {
		return new AlertEntry();
		}

		/**
		* Whether or not the alert can be removed currently. If it hasn't been on screen long enough
		* it should not be removed unless forced
		* @param key the key to check if removable
		* @return true if the alert entry can be removed
		*/
		public boolean canRemoveImmediately(String key) {
		AlertEntry alertEntry = mAlertEntries.get(key);
		return alertEntry == null \|\| alertEntry.wasShownLongEnough()
		\|\| alertEntry.mEntry.isRowDismissed();
		}

		/**
		* @param key
		* @return true if the entry is (pinned and expanded) or (has an active remote input)
		*/
		public boolean isSticky(String key) {
		AlertEntry alerting = mAlertEntries.get(key);
		if (alerting != null) {
		return alerting.isSticky();
		}
		return false;
		}

		/**
		* @param key
		* @return When a HUN entry should be removed in milliseconds from now
		*/
		public long getEarliestRemovalTime(String key) {
		AlertEntry alerting = mAlertEntries.get(key);
		if (alerting != null) {
		return Math.max(0, alerting.mEarliestRemovalTime - mSystemClock.elapsedRealtime());
		}
		return 0;
		}

		protected class AlertEntry implements Comparable<AlertEntry> {
		@Nullable public NotificationEntry mEntry;
		public long mPostTime;
		public long mEarliestRemovalTime;

		@Nullable protected Runnable mRemoveAlertRunnable;
		@Nullable private Runnable mCancelRemoveAlertRunnable;

		public void setEntry(@NonNull final NotificationEntry entry) {
		setEntry(entry, () -> removeAlertEntry(entry.getKey()));
		}

		public void setEntry(@NonNull final NotificationEntry entry,
		@Nullable Runnable removeAlertRunnable) {
		mEntry = entry;
		mRemoveAlertRunnable = removeAlertRunnable;

		mPostTime = calculatePostTime();
		updateEntry(true /* updatePostTime */, "setEntry");
		}

		/**
		* Updates an entry's removal time.
		* @param updatePostTime whether or not to refresh the post time
		*/
		public void updateEntry(boolean updatePostTime, @Nullable String reason) {
		mLogger.logUpdateEntry(mEntry, updatePostTime, reason);

		final long now = mSystemClock.elapsedRealtime();
		mEarliestRemovalTime = now + mMinimumDisplayTime;

		if (updatePostTime) {
		mPostTime = Math.max(mPostTime, now);
		}

		if (isSticky()) {
		removeAutoRemovalCallbacks("updateEntry (sticky)");
		return;
		}

		final long finishTime = calculateFinishTime();
		final long timeLeft = Math.max(finishTime - now, mMinimumDisplayTime);
		scheduleAutoRemovalCallback(timeLeft, "updateEntry (not sticky)");
		}

		/**
		* Whether or not the notification is "sticky" i.e. should stay on screen regardless
		* of the timer (forever) and should be removed externally.
		* @return true if the notification is sticky
		*/
		public boolean isSticky() {
		// This implementation is overridden by HeadsUpManager HeadsUpEntry #isSticky
		return false;
		}

		public boolean isStickyForSomeTime() {
		// This implementation is overridden by HeadsUpManager HeadsUpEntry #isStickyForSomeTime
		return false;
		}

		/**
		* Whether the notification has befen on screen long enough and can be removed.
		* @return true if the notification has been on screen long enough
		*/
		public boolean wasShownLongEnough() {
		return mEarliestRemovalTime < mSystemClock.elapsedRealtime();
		}

		@Override
		public int compareTo(@NonNull AlertEntry alertEntry) {
		return (mPostTime < alertEntry.mPostTime)
		? 1 : ((mPostTime == alertEntry.mPostTime)
		? mEntry.getKey().compareTo(alertEntry.mEntry.getKey()) : -1);
		}

		public void reset() {
		removeAutoRemovalCallbacks("reset()");
		mEntry = null;
		mRemoveAlertRunnable = null;
		}

		/**
		* Clear any pending removal runnables.
		*/
		public void removeAutoRemovalCallbacks(@Nullable String reason) {
		final boolean removed = removeAutoRemovalCallbackInternal();

		if (removed) {
		mLogger.logAutoRemoveCanceled(mEntry, reason);
		}
		}

		private void scheduleAutoRemovalCallback(long delayMillis, @NonNull String reason) {
		if (mRemoveAlertRunnable == null) {
		Log.wtf(TAG, "scheduleAutoRemovalCallback with no callback set");
		return;
		}

		final boolean removed = removeAutoRemovalCallbackInternal();

		if (removed) {
		mLogger.logAutoRemoveRescheduled(mEntry, delayMillis, reason);
		} else {
		mLogger.logAutoRemoveScheduled(mEntry, delayMillis, reason);
		}


		mCancelRemoveAlertRunnable = mExecutor.executeDelayed(mRemoveAlertRunnable,
		delayMillis);
		}

		private boolean removeAutoRemovalCallbackInternal() {
		final boolean scheduled = (mCancelRemoveAlertRunnable != null);

		if (scheduled) {
		mCancelRemoveAlertRunnable.run();
		mCancelRemoveAlertRunnable = null;
		}

		return scheduled;
		}

		/**
		* Remove the alert at the earliest allowed removal time.
		*/
		public void removeAsSoonAsPossible() {
		if (mRemoveAlertRunnable != null) {
		final long timeLeft = mEarliestRemovalTime - mSystemClock.elapsedRealtime();
		scheduleAutoRemovalCallback(timeLeft, "removeAsSoonAsPossible");
		}
		}

		/**
		* Calculate what the post time of a notification is at some current time.
		* @return the post time
		*/
		protected long calculatePostTime() {
		return mSystemClock.elapsedRealtime();
		}

		/**
		* @return When the notification should auto-dismiss itself, based on
		* {@link SystemClock#elapsedRealtime()}
		*/
		protected long calculateFinishTime() {
		// Overridden by HeadsUpManager HeadsUpEntry #calculateFinishTime
		return 0;
		}
		}
		}

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

+5 −5

Original line number	Diff line number	Diff line
		@@ -375,9 +375,9 @@ public class HeadsUpManagerPhone extends BaseHeadsUpManager implements OnHeadsUp
		}

		@Override
		protected void onAlertEntryRemoved(AlertEntry alertEntry) {
		super.onAlertEntryRemoved(alertEntry);
		mEntryPool.release((HeadsUpEntryPhone) alertEntry);
		protected void onAlertEntryRemoved(HeadsUpEntry headsUpEntry) {
		super.onAlertEntryRemoved(headsUpEntry);
		mEntryPool.release((HeadsUpEntryPhone) headsUpEntry);
		}

		@Override
		@@ -529,7 +529,7 @@ public class HeadsUpManagerPhone extends BaseHeadsUpManager implements OnHeadsUp
		mStatusBarState = newState;
		if (wasKeyguard && !isKeyguard && mBypassController.getBypassEnabled()) {
		ArrayList<String> keysToRemove = new ArrayList<>();
		for (AlertEntry entry : mAlertEntries.values()) {
		for (HeadsUpEntry entry : mAlertEntries.values()) {
		if (entry.mEntry != null && entry.mEntry.isBubble() && !entry.isSticky()) {
		keysToRemove.add(entry.mEntry.getKey());
		}
		@@ -545,7 +545,7 @@ public class HeadsUpManagerPhone extends BaseHeadsUpManager implements OnHeadsUp
		if (!isDozing) {
		// Let's make sure all huns we got while dozing time out within the normal timeout
		// duration. Otherwise they could get stuck for a very long time
		for (AlertEntry entry : mAlertEntries.values()) {
		for (HeadsUpEntry entry : mAlertEntries.values()) {
		entry.updateEntry(true /* updatePostTime */, "onDozingChanged(false)");
		}
		}

packages/SystemUI/src/com/android/systemui/statusbar/policy/BaseHeadsUpManager.java

+340 −38

File changed.

Preview size limit exceeded, changes collapsed.

packages/SystemUI/tests/src/com/android/systemui/statusbar/AlertingNotificationManagerTest.java

deleted100644 → 0

+0 −227

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2018 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;

		import static com.android.systemui.log.LogBufferHelperKt.logcatLogBuffer;
		import static com.android.systemui.statusbar.notification.row.NotificationRowContentBinder.FLAG_CONTENT_VIEW_CONTRACTED;

		import static com.google.common.truth.Truth.assertThat;

		import static junit.framework.Assert.assertFalse;
		import static junit.framework.Assert.assertTrue;

		import static org.junit.Assert.assertEquals;
		import static org.mockito.Mockito.spy;

		import android.app.ActivityManager;
		import android.app.Notification;
		import android.os.UserHandle;
		import android.service.notification.StatusBarNotification;
		import android.testing.AndroidTestingRunner;
		import android.testing.TestableLooper;

		import androidx.test.filters.SmallTest;

		import com.android.systemui.SysuiTestCase;
		import com.android.systemui.res.R;
		import com.android.systemui.statusbar.notification.collection.NotificationEntry;
		import com.android.systemui.statusbar.notification.collection.NotificationEntryBuilder;
		import com.android.systemui.statusbar.notification.row.ExpandableNotificationRow;
		import com.android.systemui.statusbar.policy.HeadsUpManagerLogger;
		import com.android.systemui.util.concurrency.DelayableExecutor;
		import com.android.systemui.util.concurrency.FakeExecutor;
		import com.android.systemui.util.settings.FakeGlobalSettings;
		import com.android.systemui.util.time.FakeSystemClock;
		import com.android.systemui.util.time.SystemClock;

		import org.junit.Rule;
		import org.junit.Test;
		import org.junit.runner.RunWith;
		import org.mockito.Mock;
		import org.mockito.junit.MockitoJUnit;
		import org.mockito.junit.MockitoRule;

		@SmallTest
		@RunWith(AndroidTestingRunner.class)
		@TestableLooper.RunWithLooper
		public class AlertingNotificationManagerTest extends SysuiTestCase {
		@Rule
		public MockitoRule rule = MockitoJUnit.rule();

		private static final String TEST_PACKAGE_NAME = "test";
		private static final int TEST_UID = 0;

		protected static final int TEST_MINIMUM_DISPLAY_TIME = 400;
		protected static final int TEST_AUTO_DISMISS_TIME = 600;
		protected static final int TEST_STICKY_AUTO_DISMISS_TIME = 800;
		// Number of notifications to use in tests requiring multiple notifications
		private static final int TEST_NUM_NOTIFICATIONS = 4;

		protected final FakeGlobalSettings mGlobalSettings = new FakeGlobalSettings();
		protected final FakeSystemClock mSystemClock = new FakeSystemClock();
		protected final FakeExecutor mExecutor = new FakeExecutor(mSystemClock);

		@Mock protected ExpandableNotificationRow mRow;

		static {
		assertThat(TEST_MINIMUM_DISPLAY_TIME).isLessThan(TEST_AUTO_DISMISS_TIME);
		assertThat(TEST_AUTO_DISMISS_TIME).isLessThan(TEST_STICKY_AUTO_DISMISS_TIME);
		}

		private static class TestableAlertingNotificationManager extends AlertingNotificationManager {
		private AlertEntry mLastCreatedEntry;

		private TestableAlertingNotificationManager(SystemClock systemClock,
		DelayableExecutor executor) {
		super(new HeadsUpManagerLogger(logcatLogBuffer()), systemClock, executor);
		mMinimumDisplayTime = TEST_MINIMUM_DISPLAY_TIME;
		mAutoDismissTime = TEST_AUTO_DISMISS_TIME;
		mStickyForSomeTimeAutoDismissTime = TEST_STICKY_AUTO_DISMISS_TIME;
		}

		@Override
		protected void onAlertEntryAdded(AlertEntry alertEntry) {}

		@Override
		protected void onAlertEntryRemoved(AlertEntry alertEntry) {}

		@Override
		protected AlertEntry createAlertEntry() {
		mLastCreatedEntry = spy(super.createAlertEntry());
		return mLastCreatedEntry;
		}

		@Override
		public int getContentFlag() {
		return FLAG_CONTENT_VIEW_CONTRACTED;
		}
		}

		protected AlertingNotificationManager createAlertingNotificationManager() {
		return new TestableAlertingNotificationManager(mSystemClock, mExecutor);
		}

		protected StatusBarNotification createSbn(int id, Notification n) {
		return new StatusBarNotification(
		TEST_PACKAGE_NAME /* pkg */,
		TEST_PACKAGE_NAME,
		id,
		null /* tag */,
		TEST_UID,
		0 /* initialPid */,
		n,
		new UserHandle(ActivityManager.getCurrentUser()),
		null /* overrideGroupKey */,
		0 /* postTime */);
		}

		protected StatusBarNotification createSbn(int id, Notification.Builder n) {
		return createSbn(id, n.build());
		}

		protected StatusBarNotification createSbn(int id) {
		final Notification.Builder b = new Notification.Builder(mContext, "")
		.setSmallIcon(R.drawable.ic_person)
		.setContentTitle("Title")
		.setContentText("Text");
		return createSbn(id, b);
		}

		protected NotificationEntry createEntry(int id, Notification n) {
		return new NotificationEntryBuilder().setSbn(createSbn(id, n)).build();
		}

		protected NotificationEntry createEntry(int id) {
		return new NotificationEntryBuilder().setSbn(createSbn(id)).build();
		}


		@Test
		public void testShowNotification_addsEntry() {
		final AlertingNotificationManager alm = createAlertingNotificationManager();
		final NotificationEntry entry = createEntry(/* id = */ 0);

		alm.showNotification(entry);

		assertTrue(alm.isAlerting(entry.getKey()));
		assertTrue(alm.hasNotifications());
		assertEquals(entry, alm.getEntry(entry.getKey()));
		}

		@Test
		public void testShowNotification_autoDismisses() {
		final AlertingNotificationManager alm = createAlertingNotificationManager();
		final NotificationEntry entry = createEntry(/* id = */ 0);

		alm.showNotification(entry);
		mSystemClock.advanceTime(TEST_AUTO_DISMISS_TIME * 3 / 2);

		assertFalse(alm.isAlerting(entry.getKey()));
		}

		@Test
		public void testRemoveNotification_removeDeferred() {
		final AlertingNotificationManager alm = createAlertingNotificationManager();
		final NotificationEntry entry = createEntry(/* id = */ 0);

		alm.showNotification(entry);

		final boolean removedImmediately = alm.removeNotification(
		entry.getKey(), /* releaseImmediately = */ false);
		assertFalse(removedImmediately);
		assertTrue(alm.isAlerting(entry.getKey()));
		}

		@Test
		public void testRemoveNotification_forceRemove() {
		final AlertingNotificationManager alm = createAlertingNotificationManager();
		final NotificationEntry entry = createEntry(/* id = */ 0);

		alm.showNotification(entry);

		final boolean removedImmediately = alm.removeNotification(
		entry.getKey(), /* releaseImmediately = */ true);
		assertTrue(removedImmediately);
		assertFalse(alm.isAlerting(entry.getKey()));
		}

		@Test
		public void testReleaseAllImmediately() {
		final AlertingNotificationManager alm = createAlertingNotificationManager();
		for (int i = 0; i < TEST_NUM_NOTIFICATIONS; i++) {
		final NotificationEntry entry = createEntry(i);
		entry.setRow(mRow);
		alm.showNotification(entry);
		}

		alm.releaseAllImmediately();

		assertEquals(0, alm.getAllEntries().count());
		}

		@Test
		public void testCanRemoveImmediately_notShownLongEnough() {
		final AlertingNotificationManager alm = createAlertingNotificationManager();
		final NotificationEntry entry = createEntry(/* id = */ 0);

		alm.showNotification(entry);

		// The entry has just been added so we should not remove immediately.
		assertFalse(alm.canRemoveImmediately(entry.getKey()));
		}
		}

packages/SystemUI/tests/src/com/android/systemui/statusbar/phone/HeadsUpManagerPhoneTest.java

+2 −8

Original line number	Diff line number	Diff line
		@@ -35,13 +35,12 @@ import com.android.internal.logging.UiEventLogger;
		import com.android.systemui.plugins.statusbar.StatusBarStateController;
		import com.android.systemui.res.R;
		import com.android.systemui.shade.domain.interactor.ShadeInteractor;
		import com.android.systemui.statusbar.AlertingNotificationManager;
		import com.android.systemui.statusbar.AlertingNotificationManagerTest;
		import com.android.systemui.statusbar.NotificationShadeWindowController;
		import com.android.systemui.statusbar.notification.collection.NotificationEntry;
		import com.android.systemui.statusbar.notification.collection.provider.VisualStabilityProvider;
		import com.android.systemui.statusbar.notification.collection.render.GroupMembershipManager;
		import com.android.systemui.statusbar.policy.AccessibilityManagerWrapper;
		import com.android.systemui.statusbar.policy.BaseHeadsUpManagerTest;
		import com.android.systemui.statusbar.policy.ConfigurationController;
		import com.android.systemui.statusbar.policy.HeadsUpManager;
		import com.android.systemui.statusbar.policy.HeadsUpManagerLogger;
		@@ -64,7 +63,7 @@ import kotlinx.coroutines.flow.StateFlowKt;
		@SmallTest
		@RunWith(AndroidTestingRunner.class)
		@TestableLooper.RunWithLooper
		public class HeadsUpManagerPhoneTest extends AlertingNotificationManagerTest {
		public class HeadsUpManagerPhoneTest extends BaseHeadsUpManagerTest {
		@Rule public MockitoRule rule = MockitoJUnit.rule();

		private final HeadsUpManagerLogger mHeadsUpManagerLogger = new HeadsUpManagerLogger(
		@@ -137,11 +136,6 @@ public class HeadsUpManagerPhoneTest extends AlertingNotificationManagerTest {
		);
		}

		@Override
		protected AlertingNotificationManager createAlertingNotificationManager() {
		return createHeadsUpManagerPhone();
		}

		@Before
		public void setUp() {
		when(mShadeInteractor.isAnyExpanded()).thenReturn(StateFlowKt.MutableStateFlow(false));