Merge "Use a different context when constructing an EdgeBackGestureHandler."...

import javax.inject.Inject;

import javax.inject.Named;

import javax.inject.Provider;

import dagger.Lazy;

     */

    public static final String ALLOW_NOTIFICATION_LONG_PRESS_NAME = "allow_notif_longpress";

    /**

     * A provider of {@link EdgeBackGestureHandler}.

     */

    public static final String EDGE_BACK_GESTURE_HANDLER_PROVIDER_NAME =

            "edge_back_gesture_handler_provider";

    /**

     * Key for getting a background Looper for background work.

     */

     */

    public static final DependencyKey<String> LEAK_REPORT_EMAIL =

            new DependencyKey<>(LEAK_REPORT_EMAIL_NAME);

    /**

     * Key for retrieving an Provider<EdgeBackGestureHandler>.

     */

    public static final DependencyKey<Provider<EdgeBackGestureHandler>>

            EDGE_BACK_GESTURE_HANDLER_PROVIDER =

            new DependencyKey<>(EDGE_BACK_GESTURE_HANDLER_PROVIDER_NAME);

    private final ArrayMap<Object, Object> mDependencies = new ArrayMap<>();

    private final ArrayMap<Object, LazyDependencyCreator> mProviders = new ArrayMap<>();

    @Inject Lazy<TelephonyListenerManager> mTelephonyListenerManager;

    @Inject Lazy<SystemStatusAnimationScheduler> mSystemStatusAnimationSchedulerLazy;

    @Inject Lazy<PrivacyDotViewController> mPrivacyDotViewControllerLazy;

    @Inject Provider<EdgeBackGestureHandler> mEdgeBackGestureHandlerProvider;

    @Inject Lazy<EdgeBackGestureHandler.Factory> mEdgeBackGestureHandlerFactoryLazy;

    @Inject Lazy<UiEventLogger> mUiEventLogger;

    @Inject Lazy<FeatureFlags> mFeatureFlagsLazy;

        mProviders.put(SystemStatusAnimationScheduler.class,

                mSystemStatusAnimationSchedulerLazy::get);

        mProviders.put(PrivacyDotViewController.class, mPrivacyDotViewControllerLazy::get);

        mProviders.put(EDGE_BACK_GESTURE_HANDLER_PROVIDER, () -> mEdgeBackGestureHandlerProvider);

        mProviders.put(EdgeBackGestureHandler.Factory.class,

                mEdgeBackGestureHandlerFactoryLazy::get);

        mProviders.put(UiEventLogger.class, mUiEventLogger::get);

        mProviders.put(FeatureFlags.class, mFeatureFlagsLazy::get);

import static android.view.WindowManagerPolicyConstants.NAV_BAR_MODE_GESTURAL;

import static com.android.systemui.Dependency.EDGE_BACK_GESTURE_HANDLER_PROVIDER;

import static com.android.systemui.shared.system.QuickStepContract.SYSUI_STATE_HOME_DISABLED;

import static com.android.systemui.shared.system.QuickStepContract.SYSUI_STATE_NOTIFICATION_PANEL_EXPANDED;

import static com.android.systemui.shared.system.QuickStepContract.SYSUI_STATE_OVERVIEW_DISABLED;

        mNavColorSampleMargin = getResources()

                        .getDimensionPixelSize(R.dimen.navigation_handle_sample_horizontal_margin);

        mEdgeBackGestureHandler = Dependency.get(EDGE_BACK_GESTURE_HANDLER_PROVIDER).get();

        mEdgeBackGestureHandler = Dependency.get(EdgeBackGestureHandler.Factory.class)

                .create(mContext);

        mEdgeBackGestureHandler.setStateChangeCallback(this::updateStates);

        mRegionSamplingHelper = new RegionSamplingHelper(this,

                new RegionSamplingHelper.SamplingCallback() {

        }

    };

    @Inject

    public EdgeBackGestureHandler(Context context, OverviewProxyService overviewProxyService,

    EdgeBackGestureHandler(Context context, OverviewProxyService overviewProxyService,

            SysUiState sysUiState, PluginManager pluginManager, @Main Executor executor,

            BroadcastDispatcher broadcastDispatcher, ProtoTracer protoTracer,

            NavigationModeController navigationModeController, ViewConfiguration viewConfiguration,

        proto.edgeBackGestureHandler.allowGesture = mAllowGesture;

    }

    /**

     * Injectable instance to create a new EdgeBackGestureHandler.

     *

     * Necessary because we don't have good handling of per-display contexts at the moment. With

     * this, you can pass in a specific context that knows what display it is in.

     */

    public static class Factory {

        private final OverviewProxyService mOverviewProxyService;

        private final SysUiState mSysUiState;

        private final PluginManager mPluginManager;

        private final Executor mExecutor;

        private final BroadcastDispatcher mBroadcastDispatcher;

        private final ProtoTracer mProtoTracer;

        private final NavigationModeController mNavigationModeController;

        private final ViewConfiguration mViewConfiguration;

        private final WindowManager mWindowManager;

        private final IWindowManager mWindowManagerService;

        private final FalsingManager mFalsingManager;

        @Inject

        public Factory(OverviewProxyService overviewProxyService,

                SysUiState sysUiState, PluginManager pluginManager, @Main Executor executor,

                BroadcastDispatcher broadcastDispatcher, ProtoTracer protoTracer,

                NavigationModeController navigationModeController,

                ViewConfiguration viewConfiguration, WindowManager windowManager,

                IWindowManager windowManagerService, FalsingManager falsingManager) {

            mOverviewProxyService = overviewProxyService;

            mSysUiState = sysUiState;

            mPluginManager = pluginManager;

            mExecutor = executor;

            mBroadcastDispatcher = broadcastDispatcher;

            mProtoTracer = protoTracer;

            mNavigationModeController = navigationModeController;

            mViewConfiguration = viewConfiguration;

            mWindowManager = windowManager;

            mWindowManagerService = windowManagerService;

            mFalsingManager = falsingManager;

        }

        /** Construct a {@link EdgeBackGestureHandler}. */

        public EdgeBackGestureHandler create(Context context) {

            return new EdgeBackGestureHandler(context, mOverviewProxyService, mSysUiState,

                    mPluginManager, mExecutor, mBroadcastDispatcher, mProtoTracer,

                    mNavigationModeController, mViewConfiguration, mWindowManager,

                    mWindowManagerService, mFalsingManager);

        }

    }

    private static class LogArray extends ArrayDeque<String> {

        private final int mLength;

package com.android.systemui.navigationbar;

import static com.android.systemui.Dependency.EDGE_BACK_GESTURE_HANDLER_PROVIDER;

import static org.junit.Assert.assertNotNull;

import static org.junit.Assert.assertTrue;

import static org.mockito.Mockito.mock;

import static org.mockito.ArgumentMatchers.any;

import static org.mockito.Mockito.when;

import android.content.Context;

import android.graphics.PixelFormat;

import android.hardware.display.DisplayManager;

import android.hardware.display.VirtualDisplay;

import com.android.systemui.SysuiTestCase;

import com.android.systemui.SysuiTestableContext;

import com.android.systemui.assist.AssistManager;

import com.android.systemui.navigationbar.NavigationBarView;

import com.android.systemui.navigationbar.gestural.EdgeBackGestureHandler;

import com.android.systemui.recents.OverviewProxyService;

import com.android.systemui.statusbar.policy.KeyguardStateController;

import org.junit.Before;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.mockito.Mock;

import org.mockito.MockitoAnnotations;

import java.util.function.Predicate;

@SmallTest

public class NavigationBarButtonTest extends SysuiTestCase {

    @Mock

    EdgeBackGestureHandler.Factory mEdgeBackGestureHandlerFactory;

    @Mock

    EdgeBackGestureHandler mEdgeBackGestureHandler;

    private static final String TAG = "NavigationBarButtonTest";

    private ImageReader mReader;

    private NavigationBarView mNavBar;

    @Before

    public void setup() {

        MockitoAnnotations.initMocks(this);

        final Display display = createVirtualDisplay();

        final SysuiTestableContext context =

                (SysuiTestableContext) mContext.createDisplayContext(display);

        when(mEdgeBackGestureHandlerFactory.create(any(Context.class)))

                .thenReturn(mEdgeBackGestureHandler);

        mDependency.injectMockDependency(AssistManager.class);

        mDependency.injectMockDependency(OverviewProxyService.class);

        mDependency.injectMockDependency(KeyguardStateController.class);

        mDependency.injectMockDependency(NavigationBarController.class);

        mDependency.injectTestDependency(EDGE_BACK_GESTURE_HANDLER_PROVIDER,

                () -> mock(EdgeBackGestureHandler.class));

        mDependency.injectTestDependency(EdgeBackGestureHandler.Factory.class,

                mEdgeBackGestureHandlerFactory);

        mNavBar = new NavigationBarView(context, null);

    }

import static android.view.DisplayAdjustments.DEFAULT_DISPLAY_ADJUSTMENTS;

import static com.android.internal.config.sysui.SystemUiDeviceConfigFlags.HOME_BUTTON_LONG_PRESS_DURATION_MS;

import static com.android.systemui.Dependency.EDGE_BACK_GESTURE_HANDLER_PROVIDER;

import static com.android.systemui.navigationbar.NavigationBar.NavBarActionEvent.NAVBAR_ASSIST_LONGPRESS;

import static org.junit.Assert.assertEquals;

    private BroadcastDispatcher mBroadcastDispatcher;

    @Mock

    private UiEventLogger mUiEventLogger;

    @Mock

    EdgeBackGestureHandler.Factory mEdgeBackGestureHandlerFactory;

    @Mock

    EdgeBackGestureHandler mEdgeBackGestureHandler;

    @Rule

    public final LeakCheckedTest.SysuiLeakCheck mLeakCheck = new LeakCheckedTest.SysuiLeakCheck();

    public void setup() throws Exception {

        MockitoAnnotations.initMocks(this);

        when(mEdgeBackGestureHandlerFactory.create(any(Context.class)))

                .thenReturn(mEdgeBackGestureHandler);

        mCommandQueue = new CommandQueue(mContext);

        setupSysuiDependency();

        mDependency.injectMockDependency(AssistManager.class);

        mDependency.injectMockDependency(StatusBarStateController.class);

        mDependency.injectMockDependency(NavigationBarController.class);

        mOverviewProxyService = mDependency.injectMockDependency(OverviewProxyService.class);

        mDependency.injectTestDependency(EDGE_BACK_GESTURE_HANDLER_PROVIDER,

                () -> mock(EdgeBackGestureHandler.class));

        mDependency.injectTestDependency(EdgeBackGestureHandler.Factory.class,

                mEdgeBackGestureHandlerFactory);

        TestableLooper.get(this).runWithLooper(() -> {

            mNavigationBar = createNavBar(mContext);

            mExternalDisplayNavigationBar = createNavBar(mSysuiTestableContextExternal);