Remove NotifBlockingHelperManager

/*

 * 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);

    }

}

/*

 * 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;

    }

}