Merge "Use full Notification LogMaker in NotificationStackScrollLayout...

            Dependency.get(NotificationEntryManager.class);

    private final IStatusBarService mBarService = IStatusBarService.Stub.asInterface(

            ServiceManager.getService(Context.STATUS_BAR_SERVICE));

    private final MetricsLogger mMetricsLogger = Dependency.get(MetricsLogger.class);

    @VisibleForTesting

    protected final MetricsLogger mMetricsLogger = Dependency.get(MetricsLogger.class);

    private final NotificationRemoteInputManager mRemoteInputManager =

            Dependency.get(NotificationRemoteInputManager.class);

    private final SysuiColorExtractor mColorExtractor = Dependency.get(SysuiColorExtractor.class);

      }

    };

    @VisibleForTesting

    @ShadeViewRefactor(RefactorComponent.INPUT)

    private final OnMenuEventListener mMenuEventListener = new OnMenuEventListener() {

    protected final OnMenuEventListener mMenuEventListener = new OnMenuEventListener() {

        @Override

        public void onMenuClicked(View view, int x, int y, MenuItem item) {

            if (mLongPressListener == null) {

            }

            if (view instanceof ExpandableNotificationRow) {

                ExpandableNotificationRow row = (ExpandableNotificationRow) view;

                MetricsLogger.action(mContext, MetricsEvent.ACTION_TOUCH_GEAR,

                        row.getStatusBarNotification().getPackageName());

                mMetricsLogger.write(row.getStatusBarNotification().getLogMaker()

                        .setCategory(MetricsEvent.ACTION_TOUCH_GEAR)

                        .setType(MetricsEvent.TYPE_ACTION)

                        );

            }

            mLongPressListener.onLongPress(view, x, y, item);

        }

        public void onMenuShown(View row) {

            if (row instanceof ExpandableNotificationRow) {

                ExpandableNotificationRow notificationRow = (ExpandableNotificationRow) row;

                MetricsLogger.action(mContext, MetricsEvent.ACTION_REVEAL_GEAR,

                        notificationRow.getStatusBarNotification().getPackageName());

                mMetricsLogger.write(notificationRow.getStatusBarNotification().getLogMaker()

                        .setCategory(MetricsEvent.ACTION_REVEAL_GEAR)

                        .setType(MetricsEvent.TYPE_ACTION));

                mHeadsUpManager.setMenuShown(notificationRow.getEntry(), true);

            }

            mSwipeHelper.onMenuShown(row);

import static org.mockito.ArgumentMatchers.any;

import static org.mockito.ArgumentMatchers.anyBoolean;

import static org.mockito.ArgumentMatchers.anyInt;

import static org.mockito.ArgumentMatchers.argThat;

import static org.mockito.ArgumentMatchers.eq;

import static org.mockito.Mockito.RETURNS_DEEP_STUBS;

import static org.mockito.Mockito.atLeastOnce;

import static org.mockito.Mockito.verify;

import static org.mockito.Mockito.when;

import android.metrics.LogMaker;

import android.provider.Settings;

import android.support.test.annotation.UiThreadTest;

import android.support.test.filters.SmallTest;

import android.support.test.runner.AndroidJUnit4;

import android.view.View;

import com.android.internal.logging.MetricsLogger;

import com.android.internal.logging.nano.MetricsProto;

import com.android.systemui.Dependency;

import com.android.systemui.ExpandHelper;

import com.android.systemui.InitController;

import com.android.systemui.R;

import com.android.systemui.SysuiTestCase;

import com.android.systemui.plugins.statusbar.NotificationMenuRowPlugin;

import com.android.systemui.statusbar.EmptyShadeView;

import com.android.systemui.statusbar.NotificationPresenter;

import com.android.systemui.statusbar.NotificationRemoteInputManager;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.mockito.ArgumentCaptor;

import org.mockito.ArgumentMatcher;

import org.mockito.Mock;

import org.mockito.junit.MockitoJUnit;

import org.mockito.junit.MockitoRule;

@RunWith(AndroidJUnit4.class)

public class NotificationStackScrollLayoutTest extends SysuiTestCase {

    private NotificationStackScrollLayout mStackScroller;

    private NotificationStackScrollLayout mStackScroller;  // Normally test this

    private NotificationStackScrollLayout mStackScrollerInternal;  // See explanation below

    @Rule public MockitoRule mockito = MockitoJUnit.rule();

    @Mock private StatusBar mBar;

    @Mock private NotificationData mNotificationData;

    @Mock private NotificationRemoteInputManager mRemoteInputManager;

    @Mock private RemoteInputController mRemoteInputController;

    @Mock private MetricsLogger mMetricsLogger;

    private TestableNotificationEntryManager mEntryManager;

    private int mOriginalInterruptionModelSetting;

    @Before

    @UiThreadTest

    public void setUp() throws Exception {

                NotificationBlockingHelperManager.class,

                mBlockingHelperManager);

        mDependency.injectTestDependency(StatusBarStateController.class, mBarState);

        mDependency.injectTestDependency(MetricsLogger.class, mMetricsLogger);

        mDependency.injectTestDependency(NotificationRemoteInputManager.class,

                mRemoteInputManager);

        mDependency.injectMockDependency(ShadeController.class);

        NotificationShelf notificationShelf = mock(NotificationShelf.class);

        mStackScroller = spy(new NotificationStackScrollLayout(getContext(), null,

                true /* allowLongPress */));

        // The actual class under test.  You may need to work with this class directly when

        // testing anonymous class members of mStackScroller, like mMenuEventListener,

        // which refer to members of NotificationStackScrollLayout. The spy

        // holds a copy of the CUT's instances of these classes, so they still refer to the CUT's

        // member variables, not the spy's member variables.

        mStackScrollerInternal = new NotificationStackScrollLayout(getContext(), null,

                true /* allowLongPress */);

        mStackScroller = spy(mStackScrollerInternal);

        mStackScroller.setShelf(notificationShelf);

        mStackScroller.setStatusBar(mBar);

        mStackScroller.setScrimController(mock(ScrimController.class));

        assertNull(swipeActionHelper.getExposedMenuView());

    }

    class LogMatcher implements ArgumentMatcher<LogMaker> {

        private int mCategory, mType;

        LogMatcher(int category, int type) {

            mCategory = category;

            mType = type;

        }

        public boolean matches(LogMaker l) {

            return (l.getCategory() == mCategory)

                    && (l.getType() == mType);

        }

        public String toString() {

            return String.format("LogMaker(%d, %d)", mCategory, mType);

        }

    }

    private LogMaker logMatcher(int category, int type) {

        return argThat(new LogMatcher(category, type));

    }

    @Test

    @UiThreadTest

    public void testOnMenuClickedLogging() {

        // Set up the object under test to have a valid mLongPressListener.  We're testing an

        // anonymous-class member, mMenuEventListener, so we need to modify the state of the

        // class itself, not the Mockito spy copied from it.  See notes in setup.

        mStackScrollerInternal.setLongPressListener(

                mock(ExpandableNotificationRow.LongPressListener.class));

        ExpandableNotificationRow row = mock(ExpandableNotificationRow.class, RETURNS_DEEP_STUBS);

        when(row.getStatusBarNotification().getLogMaker()).thenReturn(new LogMaker(

                MetricsProto.MetricsEvent.VIEW_UNKNOWN));

        mStackScroller.mMenuEventListener.onMenuClicked(row, 0, 0, mock(

                NotificationMenuRowPlugin.MenuItem.class));

        verify(row.getStatusBarNotification()).getLogMaker();  // This writes most of the log data

        verify(mMetricsLogger).write(logMatcher(MetricsProto.MetricsEvent.ACTION_TOUCH_GEAR,

                MetricsProto.MetricsEvent.TYPE_ACTION));

    }

    @Test

    @UiThreadTest

    public void testOnMenuShownLogging() {

        // Set up the object under test to have a valid mHeadsUpManager. See notes in setup.

        mStackScrollerInternal.setHeadsUpManager(mHeadsUpManager);

        ExpandableNotificationRow row = mock(ExpandableNotificationRow.class, RETURNS_DEEP_STUBS);

        when(row.getStatusBarNotification().getLogMaker()).thenReturn(new LogMaker(

                MetricsProto.MetricsEvent.VIEW_UNKNOWN));

        mStackScroller.mMenuEventListener.onMenuShown(row);

        verify(row.getStatusBarNotification()).getLogMaker();  // This writes most of the log data

        verify(mMetricsLogger).write(logMatcher(MetricsProto.MetricsEvent.ACTION_REVEAL_GEAR,

                MetricsProto.MetricsEvent.TYPE_ACTION));

    }

    private void setBarStateForTest(int state) {

        // Can't inject this through the listener or we end up on the actual implementation

        // rather than the mock because the spy just coppied the anonymous inner /shruggie.