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

Merge "Remove NotifBlockingHelperManager" into tm-qpr-dev

Browse Source
This commit is contained in:
Steve Elliott
2022-08-31 00:59:56 +00:00
committed by Android (Google) Code Review
parent 30156a84e3 8f4585bcc2
commit afa71b9a76
2 changed files with 0 additions and 508 deletions
Download Patch File Download Diff File Expand all files Collapse all files

206
packages/SystemUI/src/com/android/systemui/statusbar/notification/row/NotificationBlockingHelperManager.java
View File

@@ -1,206 +0,0 @@
/*
* 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.notification.row;
import static android.service.notification.NotificationListenerService.Ranking.USER_SENTIMENT_NEGATIVE;
import android.content.Context;
import android.metrics.LogMaker;
import android.util.Log;
import androidx.annotation.VisibleForTesting;
import com.android.internal.logging.MetricsLogger;
import com.android.internal.logging.nano.MetricsProto.MetricsEvent;
import com.android.systemui.plugins.statusbar.NotificationMenuRowPlugin;
import com.android.systemui.statusbar.notification.NotificationEntryManager;
import com.android.systemui.statusbar.notification.collection.NotificationEntry;
import com.android.systemui.statusbar.notification.collection.render.GroupMembershipManager;
import com.android.systemui.statusbar.notification.dagger.NotificationsModule;
import com.android.systemui.statusbar.notification.logging.NotificationCounters;
import com.android.systemui.util.Compile;
import java.util.Collections;
import java.util.HashSet;
import java.util.Set;
/**
* Manager for the notification blocking helper - tracks and helps create the blocking helper
* affordance.
*/
public class NotificationBlockingHelperManager {
/** Enables debug logging and always makes the blocking helper show up after a dismiss. */
private static final String TAG = "BlockingHelper";
private static final boolean DEBUG = Compile.IS_DEBUG && Log.isLoggable(TAG, Log.DEBUG);
private static final boolean DEBUG_ALWAYS_SHOW = false;
private final Context mContext;
private final NotificationGutsManager mNotificationGutsManager;
private final NotificationEntryManager mNotificationEntryManager;
private final MetricsLogger mMetricsLogger;
private final GroupMembershipManager mGroupMembershipManager;
/** Row that the blocking helper will be shown in (via {@link NotificationGuts}. */
private ExpandableNotificationRow mBlockingHelperRow;
private Set<String> mNonBlockablePkgs;
/**
* Whether the notification shade/stack is expanded - used to determine blocking helper
* eligibility.
*/
private boolean mIsShadeExpanded;
/**
* Injected constructor. See {@link NotificationsModule}.
*/
public NotificationBlockingHelperManager(
Context context,
NotificationGutsManager notificationGutsManager,
NotificationEntryManager notificationEntryManager,
MetricsLogger metricsLogger,
GroupMembershipManager groupMembershipManager) {
mContext = context;
mNotificationGutsManager = notificationGutsManager;
mNotificationEntryManager = notificationEntryManager;
mMetricsLogger = metricsLogger;
mNonBlockablePkgs = new HashSet<>();
Collections.addAll(mNonBlockablePkgs, mContext.getResources().getStringArray(
com.android.internal.R.array.config_nonBlockableNotificationPackages));
mGroupMembershipManager = groupMembershipManager;
}
/**
* Potentially shows the blocking helper, represented via the {@link NotificationInfo} menu
* item, in the current row if user sentiment is negative.
*
* @param row row to render the blocking helper in
* @param menuRow menu used to generate the {@link NotificationInfo} view that houses the
* blocking helper UI
* @return whether we're showing a blocking helper in the given notification row
*/
boolean perhapsShowBlockingHelper(
ExpandableNotificationRow row, NotificationMenuRowPlugin menuRow) {
// We only show the blocking helper if:
// - User sentiment is negative (DEBUG flag can bypass)
// - The notification shade is fully expanded (guarantees we're not touching a HUN).
// - The row is blockable (i.e. not non-blockable)
// - The dismissed row is a valid group (>1 or 0 children from the same channel)
// or the only child in the group
final NotificationEntry entry = row.getEntry();
if ((entry.getUserSentiment() == USER_SENTIMENT_NEGATIVE || DEBUG_ALWAYS_SHOW)
&& mIsShadeExpanded
&& !row.getIsNonblockable()
&& ((!row.isChildInGroup() || mGroupMembershipManager.isOnlyChildInGroup(entry))
&& row.getNumUniqueChannels() <= 1)) {
// Dismiss any current blocking helper before continuing forward (only one can be shown
// at a given time).
dismissCurrentBlockingHelper();
if (DEBUG) {
Log.d(TAG, "Manager.perhapsShowBlockingHelper: Showing new blocking helper");
}
// Enable blocking helper on the row before moving forward so everything in the guts is
// correctly prepped.
mBlockingHelperRow = row;
mBlockingHelperRow.setBlockingHelperShowing(true);
// Log triggering of blocking helper by the system. This log line
// should be emitted before the "display" log line.
mMetricsLogger.write(
getLogMaker().setSubtype(MetricsEvent.BLOCKING_HELPER_TRIGGERED_BY_SYSTEM));
// We don't care about the touch origin (x, y) since we're opening guts without any
// explicit user interaction.
mNotificationGutsManager.openGuts(
mBlockingHelperRow, 0, 0, menuRow.getLongpressMenuItem(mContext));
mMetricsLogger.count(NotificationCounters.BLOCKING_HELPER_SHOWN, 1);
return true;
}
return false;
}
/**
* Dismiss the currently showing blocking helper, if any, through a notification update.
*
* @return whether the blocking helper was dismissed
*/
boolean dismissCurrentBlockingHelper() {
if (!isBlockingHelperRowNull()) {
if (DEBUG) {
Log.d(TAG, "Manager.dismissCurrentBlockingHelper: Dismissing current helper");
}
if (!mBlockingHelperRow.isBlockingHelperShowing()) {
Log.e(TAG, "Manager.dismissCurrentBlockingHelper: "
+ "Non-null row is not showing a blocking helper");
}
mBlockingHelperRow.setBlockingHelperShowing(false);
if (mBlockingHelperRow.isAttachedToWindow()) {
mNotificationEntryManager.updateNotifications("dismissCurrentBlockingHelper");
}
mBlockingHelperRow = null;
return true;
}
return false;
}
/**
* Update the expansion status of the notification shade/stack.
*
* @param expandedHeight how much the shade is expanded ({code 0} indicating it's collapsed)
*/
public void setNotificationShadeExpanded(float expandedHeight) {
mIsShadeExpanded = expandedHeight > 0.0f;
}
/**
* Returns whether the given package name is in the list of non-blockable packages.
*/
public boolean isNonblockable(String packageName, String channelName) {
return mNonBlockablePkgs.contains(packageName)
|| mNonBlockablePkgs.contains(makeChannelKey(packageName, channelName));
}
private LogMaker getLogMaker() {
return mBlockingHelperRow.getEntry().getSbn()
.getLogMaker()
.setCategory(MetricsEvent.NOTIFICATION_BLOCKING_HELPER);
}
// Format must stay in sync with frameworks/base/core/res/res/values/config.xml
// config_nonBlockableNotificationPackages
private String makeChannelKey(String pkg, String channel) {
return pkg + ":" + channel;
}
@VisibleForTesting
boolean isBlockingHelperRowNull() {
return mBlockingHelperRow == null;
}
@VisibleForTesting
void setBlockingHelperRowForTest(ExpandableNotificationRow blockingHelperRowForTest) {
mBlockingHelperRow = blockingHelperRowForTest;
}
@VisibleForTesting
void setNonBlockablePkgs(String[] pkgsAndChannels) {
mNonBlockablePkgs = new HashSet<>();
Collections.addAll(mNonBlockablePkgs, pkgsAndChannels);
}
}

302
packages/SystemUI/tests/src/com/android/systemui/statusbar/notification/row/NotificationBlockingHelperManagerTest.java
View File

@@ -1,302 +0,0 @@
/*
* 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.notification.row;
import static android.app.NotificationManager.IMPORTANCE_DEFAULT;
import static android.service.notification.NotificationListenerService.Ranking.USER_SENTIMENT_NEGATIVE;
import static android.service.notification.NotificationListenerService.Ranking.USER_SENTIMENT_NEUTRAL;
import static android.service.notification.NotificationListenerService.Ranking.USER_SENTIMENT_POSITIVE;
import static com.android.systemui.statusbar.NotificationEntryHelper.modifyRanking;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import android.app.NotificationChannel;
import android.content.Context;
import android.testing.AndroidTestingRunner;
import android.testing.TestableLooper;
import android.view.View;
import androidx.test.filters.FlakyTest;
import androidx.test.filters.SmallTest;
import com.android.internal.logging.MetricsLogger;
import com.android.systemui.SysuiTestCase;
import com.android.systemui.plugins.statusbar.NotificationMenuRowPlugin;
import com.android.systemui.statusbar.notification.NotificationEntryManager;
import com.android.systemui.statusbar.notification.collection.render.GroupMembershipManager;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
/**
* Tests for {@link NotificationBlockingHelperManager}.
*/
@SmallTest
@FlakyTest
@org.junit.runner.RunWith(AndroidTestingRunner.class)
@TestableLooper.RunWithLooper
public class NotificationBlockingHelperManagerTest extends SysuiTestCase {
private NotificationBlockingHelperManager mBlockingHelperManager;
private NotificationTestHelper mHelper;
@Mock private NotificationGutsManager mGutsManager;
@Mock private NotificationEntryManager mEntryManager;
@Mock private NotificationMenuRow mMenuRow;
@Mock private NotificationMenuRowPlugin.MenuItem mMenuItem;
@Mock private GroupMembershipManager mGroupMembershipManager;
@Before
public void setUp() {
allowTestableLooperAsMainThread();
MockitoAnnotations.initMocks(this);
when(mGutsManager.openGuts(
any(View.class),
anyInt(),
anyInt(),
any(NotificationMenuRowPlugin.MenuItem.class)))
.thenReturn(true);
when(mMenuRow.getLongpressMenuItem(any(Context.class))).thenReturn(mMenuItem);
mHelper = new NotificationTestHelper(mContext, mDependency, TestableLooper.get(this));
mBlockingHelperManager = new NotificationBlockingHelperManager(
mContext, mGutsManager, mEntryManager, mock(MetricsLogger.class),
mGroupMembershipManager);
// By default, have the shade visible/expanded.
mBlockingHelperManager.setNotificationShadeExpanded(1f);
}
@Test
public void testDismissCurrentBlockingHelper_nullBlockingHelperRow() {
// By default, this shouldn't dismiss (no pointers/vars set up!)
assertFalse(mBlockingHelperManager.dismissCurrentBlockingHelper());
assertTrue(mBlockingHelperManager.isBlockingHelperRowNull());
}
@Test
public void testDismissCurrentBlockingHelper_withDetachedBlockingHelperRow() throws Exception {
ExpandableNotificationRow row = createBlockableRowSpy();
row.setBlockingHelperShowing(true);
when(row.isAttachedToWindow()).thenReturn(false);
mBlockingHelperManager.setBlockingHelperRowForTest(row);
assertTrue(mBlockingHelperManager.dismissCurrentBlockingHelper());
assertTrue(mBlockingHelperManager.isBlockingHelperRowNull());
verify(mEntryManager, times(0)).updateNotifications(anyString());
}
@Test
public void testDismissCurrentBlockingHelper_withAttachedBlockingHelperRow() throws Exception {
ExpandableNotificationRow row = createBlockableRowSpy();
row.setBlockingHelperShowing(true);
when(row.isAttachedToWindow()).thenReturn(true);
mBlockingHelperManager.setBlockingHelperRowForTest(row);
assertTrue(mBlockingHelperManager.dismissCurrentBlockingHelper());
assertTrue(mBlockingHelperManager.isBlockingHelperRowNull());
verify(mEntryManager).updateNotifications(anyString());
}
@Test
public void testPerhapsShowBlockingHelper_shown() throws Exception {
ExpandableNotificationRow row = createBlockableRowSpy();
modifyRanking(row.getEntry())
.setUserSentiment(USER_SENTIMENT_NEGATIVE)
.build();
assertTrue(mBlockingHelperManager.perhapsShowBlockingHelper(row, mMenuRow));
verify(mGutsManager).openGuts(row, 0, 0, mMenuItem);
}
@Test
public void testPerhapsShowBlockingHelper_notShownForMultiChannelGroup() throws Exception {
ExpandableNotificationRow groupRow = createBlockableGroupRowSpy(10);
int i = 0;
for (ExpandableNotificationRow childRow : groupRow.getAttachedChildren()) {
modifyRanking(childRow.getEntry())
.setChannel(
new NotificationChannel(
Integer.toString(i++), "", IMPORTANCE_DEFAULT))
.build();
}
modifyRanking(groupRow.getEntry())
.setUserSentiment(USER_SENTIMENT_NEGATIVE)
.build();
assertFalse(mBlockingHelperManager.perhapsShowBlockingHelper(groupRow, mMenuRow));
verify(mGutsManager, never()).openGuts(groupRow, 0, 0, mMenuItem);
}
@Test
public void testPerhapsShowBlockingHelper_shownForLargeGroup() throws Exception {
ExpandableNotificationRow groupRow = createBlockableGroupRowSpy(10);
modifyRanking(groupRow.getEntry())
.setUserSentiment(USER_SENTIMENT_NEGATIVE)
.build();
assertTrue(mBlockingHelperManager.perhapsShowBlockingHelper(groupRow, mMenuRow));
verify(mGutsManager).openGuts(groupRow, 0, 0, mMenuItem);
}
@Test
public void testPerhapsShowBlockingHelper_shownForOnlyChildNotification()
throws Exception {
ExpandableNotificationRow groupRow = createBlockableGroupRowSpy(1);
// Explicitly get the children container & call getViewAtPosition on it instead of the row
// as other factors such as view expansion may cause us to get the parent row back instead
// of the child row.
ExpandableNotificationRow childRow = groupRow.getChildrenContainer().getViewAtPosition(0);
modifyRanking(childRow.getEntry())
.setUserSentiment(USER_SENTIMENT_NEGATIVE)
.build();
assertFalse(childRow.getIsNonblockable());
when(mGroupMembershipManager.isOnlyChildInGroup(childRow.getEntry())).thenReturn(true);
assertTrue(mBlockingHelperManager.perhapsShowBlockingHelper(childRow, mMenuRow));
verify(mGutsManager).openGuts(childRow, 0, 0, mMenuItem);
}
@Test
public void testPerhapsShowBlockingHelper_notShownDueToNeutralUserSentiment() throws Exception {
ExpandableNotificationRow row = createBlockableRowSpy();
modifyRanking(row.getEntry())
.setUserSentiment(USER_SENTIMENT_NEUTRAL)
.build();
assertFalse(mBlockingHelperManager.perhapsShowBlockingHelper(row, mMenuRow));
}
@Test
public void testPerhapsShowBlockingHelper_notShownDueToPositiveUserSentiment()
throws Exception {
ExpandableNotificationRow row = createBlockableRowSpy();
modifyRanking(row.getEntry())
.setUserSentiment(USER_SENTIMENT_POSITIVE)
.build();
assertFalse(mBlockingHelperManager.perhapsShowBlockingHelper(row, mMenuRow));
}
@Test
public void testPerhapsShowBlockingHelper_notShownDueToShadeVisibility() throws Exception {
ExpandableNotificationRow row = createBlockableRowSpy();
modifyRanking(row.getEntry())
.setUserSentiment(USER_SENTIMENT_NEGATIVE)
.build();
// Hide the shade
mBlockingHelperManager.setNotificationShadeExpanded(0f);
assertFalse(mBlockingHelperManager.perhapsShowBlockingHelper(row, mMenuRow));
}
@Test
public void testPerhapsShowBlockingHelper_notShownDueToNonblockability() throws Exception {
ExpandableNotificationRow row = createBlockableRowSpy();
when(row.getIsNonblockable()).thenReturn(true);
modifyRanking(row.getEntry())
.setUserSentiment(USER_SENTIMENT_NEGATIVE)
.build();
assertFalse(mBlockingHelperManager.perhapsShowBlockingHelper(row, mMenuRow));
}
@Test
public void testPerhapsShowBlockingHelper_notShownAsNotificationIsInMultipleChildGroup()
throws Exception {
ExpandableNotificationRow groupRow = createBlockableGroupRowSpy(2);
// Explicitly get the children container & call getViewAtPosition on it instead of the row
// as other factors such as view expansion may cause us to get the parent row back instead
// of the child row.
ExpandableNotificationRow childRow = groupRow.getChildrenContainer().getViewAtPosition(0);
modifyRanking(childRow.getEntry())
.setUserSentiment(USER_SENTIMENT_NEGATIVE)
.build();
assertFalse(mBlockingHelperManager.perhapsShowBlockingHelper(childRow, mMenuRow));
}
@Test
public void testBlockingHelperShowAndDismiss() throws Exception{
ExpandableNotificationRow row = createBlockableRowSpy();
modifyRanking(row.getEntry())
.setUserSentiment(USER_SENTIMENT_NEGATIVE)
.build();
when(row.isAttachedToWindow()).thenReturn(true);
// Show check
assertTrue(mBlockingHelperManager.perhapsShowBlockingHelper(row, mMenuRow));
verify(mGutsManager).openGuts(row, 0, 0, mMenuItem);
// Dismiss check
assertTrue(mBlockingHelperManager.dismissCurrentBlockingHelper());
assertTrue(mBlockingHelperManager.isBlockingHelperRowNull());
verify(mEntryManager).updateNotifications(anyString());
}
@Test
public void testNonBlockable_package() {
mBlockingHelperManager.setNonBlockablePkgs(new String[] {"banana", "strawberry:pie"});
assertFalse(mBlockingHelperManager.isNonblockable("orange", "pie"));
assertTrue(mBlockingHelperManager.isNonblockable("banana", "pie"));
}
@Test
public void testNonBlockable_channel() {
mBlockingHelperManager.setNonBlockablePkgs(new String[] {"banana", "strawberry:pie"});
assertFalse(mBlockingHelperManager.isNonblockable("strawberry", "shortcake"));
assertTrue(mBlockingHelperManager.isNonblockable("strawberry", "pie"));
}
private ExpandableNotificationRow createBlockableRowSpy() throws Exception {
ExpandableNotificationRow row = spy(mHelper.createRow());
when(row.getIsNonblockable()).thenReturn(false);
return row;
}
private ExpandableNotificationRow createBlockableGroupRowSpy(int numChildren) throws Exception {
ExpandableNotificationRow row = spy(mHelper.createGroup(numChildren));
when(row.getIsNonblockable()).thenReturn(false);
return row;
}
}