Merge changes Id02aa26e,Iaafb1a0a into sc-dev

* changes:
  Refactor One handed mode Unit tests
  Do not register + unregister DA in the same call

libs/WindowManager/Shell/src/com/android/wm/shell/onehanded/OneHandedController.java

@@ -32,6 +32,7 @@ import android.os.ServiceManager;
 import android.os.SystemProperties;
 import android.provider.Settings;
 import android.util.Slog;
+import android.view.ViewConfiguration;
 import android.view.accessibility.AccessibilityManager;
 
 import androidx.annotation.NonNull;
@@ -155,7 +156,7 @@ public class OneHandedController {
         OneHandedTouchHandler touchHandler = new OneHandedTouchHandler(timeoutHandler,
                 mainExecutor);
         OneHandedGestureHandler gestureHandler = new OneHandedGestureHandler(
-                context, displayController, mainExecutor);
+                context, displayController, ViewConfiguration.get(context), mainExecutor);
         OneHandedBackgroundPanelOrganizer oneHandedBackgroundPanelOrganizer =
                 new OneHandedBackgroundPanelOrganizer(context, displayController, mainExecutor);
         OneHandedDisplayAreaOrganizer organizer = new OneHandedDisplayAreaOrganizer(
@@ -223,8 +224,7 @@ public class OneHandedController {
         setupGesturalOverlay();
         updateSettings();
 
-        mAccessibilityManager = (AccessibilityManager)
+        mAccessibilityManager = AccessibilityManager.getInstance(context);
-                context.getSystemService(Context.ACCESSIBILITY_SERVICE);
         mAccessibilityManager.addAccessibilityStateChangeListener(
                 mAccessibilityStateChangeListener);
     }
@@ -346,7 +346,8 @@ public class OneHandedController {
         };
     }
 
-    private void onEnabledSettingChanged() {
+    @VisibleForTesting
+    void onEnabledSettingChanged() {
         final boolean enabled = OneHandedSettingsUtil.getSettingsOneHandedModeEnabled(
                 mContext.getContentResolver());
         mOneHandedUiEventLogger.writeEvent(enabled
@@ -361,7 +362,8 @@ public class OneHandedController {
                         mContext.getContentResolver()));
     }
 
-    private void onTimeoutSettingChanged() {
+    @VisibleForTesting
+    void onTimeoutSettingChanged() {
         final int newTimeout = OneHandedSettingsUtil.getSettingsOneHandedModeTimeout(
                 mContext.getContentResolver());
         int metricsId = OneHandedUiEventLogger.OneHandedSettingsTogglesEvent.INVALID.getId();
@@ -389,7 +391,8 @@ public class OneHandedController {
         }
     }
 
-    private void onTaskChangeExitSettingChanged() {
+    @VisibleForTesting
+    void onTaskChangeExitSettingChanged() {
         final boolean enabled = OneHandedSettingsUtil.getSettingsTapsAppToExit(
                 mContext.getContentResolver());
         mOneHandedUiEventLogger.writeEvent(enabled
@@ -399,7 +402,8 @@ public class OneHandedController {
         setTaskChangeToExit(enabled);
     }
 
-    private void onSwipeToNotificationEnabledSettingChanged() {
+    @VisibleForTesting
+    void onSwipeToNotificationEnabledSettingChanged() {
         final boolean enabled =
                 OneHandedSettingsUtil.getSettingsSwipeToNotificationEnabled(
                         mContext.getContentResolver());
@@ -433,17 +437,26 @@ public class OneHandedController {
         if (mDisplayAreaOrganizer.isInOneHanded()) {
             stopOneHanded();
         }
-        // TODO Be aware to unregisterOrganizer() after animation finished
+
-        mDisplayAreaOrganizer.unregisterOrganizer();
+        mTouchHandler.onOneHandedEnabled(mIsOneHandedEnabled);
-        mBackgroundPanelOrganizer.unregisterOrganizer();
+        mGestureHandler.onOneHandedEnabled(mIsOneHandedEnabled || mIsSwipeToNotificationEnabled);
-        if (mIsOneHandedEnabled) {
+
+        if (!mIsOneHandedEnabled) {
+            mDisplayAreaOrganizer.unregisterOrganizer();
+            mBackgroundPanelOrganizer.unregisterOrganizer();
+            // Do NOT register + unRegister DA in the same call
+            return;
+        }
+
+        if (mDisplayAreaOrganizer.getDisplayAreaTokenMap().isEmpty()) {
             mDisplayAreaOrganizer.registerOrganizer(
                     OneHandedDisplayAreaOrganizer.FEATURE_ONE_HANDED);
+        }
+
+        if (mBackgroundPanelOrganizer.getBackgroundSurface() == null) {
             mBackgroundPanelOrganizer.registerOrganizer(
                     OneHandedBackgroundPanelOrganizer.FEATURE_ONE_HANDED_BACKGROUND_PANEL);
         }
-        mTouchHandler.onOneHandedEnabled(mIsOneHandedEnabled);
-        mGestureHandler.onOneHandedEnabled(mIsOneHandedEnabled || mIsSwipeToNotificationEnabled);
     }
 
     private void setupGesturalOverlay() {
@@ -453,7 +466,6 @@ public class OneHandedController {
 
         OverlayInfo info = null;
         try {
-            // TODO(b/157958539) migrate new RRO config file after S+
             mOverlayManager.setHighestPriority(ONE_HANDED_MODE_GESTURAL_OVERLAY, USER_CURRENT);
             info = mOverlayManager.getOverlayInfo(ONE_HANDED_MODE_GESTURAL_OVERLAY, USER_CURRENT);
         } catch (RemoteException e) { /* Do nothing */ }

libs/WindowManager/Shell/src/com/android/wm/shell/onehanded/OneHandedDisplayAreaOrganizer.java

@@ -66,8 +66,7 @@ public class OneHandedDisplayAreaOrganizer extends DisplayAreaOrganizer {
     private boolean mIsInOneHanded;
     private int mEnterExitAnimationDurationMs;
 
-    @VisibleForTesting
+    private ArrayMap<WindowContainerToken, SurfaceControl> mDisplayAreaTokenMap = new ArrayMap();
-    ArrayMap<WindowContainerToken, SurfaceControl> mDisplayAreaTokenMap = new ArrayMap();
     private DisplayController mDisplayController;
     private OneHandedAnimationController mAnimationController;
     private OneHandedSurfaceTransactionHelper.SurfaceControlTransactionFactory
@@ -298,6 +297,11 @@ public class OneHandedDisplayAreaOrganizer extends DisplayAreaOrganizer {
         return new Rect(0, 0, realSize.x, realSize.y);
     }
 
+    @VisibleForTesting
+    ArrayMap<WindowContainerToken, SurfaceControl> getDisplayAreaTokenMap() {
+        return mDisplayAreaTokenMap;
+    }
+
     /**
      * Register transition callback
      */

libs/WindowManager/Shell/src/com/android/wm/shell/onehanded/OneHandedGestureHandler.java

@@ -87,6 +87,7 @@ public class OneHandedGestureHandler implements OneHandedTransitionCallback,
      * @param displayController        {@link DisplayController}
      */
     public OneHandedGestureHandler(Context context, DisplayController displayController,
+            ViewConfiguration viewConfig,
             ShellExecutor mainExecutor) {
         mDisplayController = displayController;
         mMainExecutor = mainExecutor;
@@ -95,7 +96,7 @@ public class OneHandedGestureHandler implements OneHandedTransitionCallback,
                 com.android.internal.R.dimen.navigation_bar_gesture_larger_height);
         mDragDistThreshold = context.getResources().getDimensionPixelSize(
                 R.dimen.gestures_onehanded_drag_threshold);
-        final float slop = ViewConfiguration.get(context).getScaledTouchSlop();
+        final float slop = viewConfig.getScaledTouchSlop();
         mSquaredSlop = slop * slop;
 
         updateIsEnabled();

libs/WindowManager/Shell/src/com/android/wm/shell/onehanded/OneHandedTutorialHandler.java

@@ -107,8 +107,7 @@ public class OneHandedTutorialHandler implements OneHandedTransitionCallback {
         mPackageName = context.getPackageName();
         mContentResolver = context.getContentResolver();
         mWindowManager = context.getSystemService(WindowManager.class);
-        mAccessibilityManager = (AccessibilityManager)
+        mAccessibilityManager = AccessibilityManager.getInstance(context);
-                context.getSystemService(Context.ACCESSIBILITY_SERVICE);
 
         mStartOneHandedDescription = context.getResources().getString(
                 R.string.accessibility_action_start_one_handed);

libs/WindowManager/Shell/tests/unittest/src/com/android/wm/shell/onehanded/OneHandedAnimationControllerTest.java

@@ -47,7 +47,6 @@ public class OneHandedAnimationControllerTest extends OneHandedTestCase {
     private static final int TEST_BOUNDS_HEIGHT = 1000;
 
     OneHandedAnimationController mOneHandedAnimationController;
-    OneHandedTutorialHandler mTutorialHandler;
 
     @Mock
     private SurfaceControl mMockLeash;
@@ -60,8 +59,6 @@ public class OneHandedAnimationControllerTest extends OneHandedTestCase {
     @Before
     public void setUp() throws Exception {
         MockitoAnnotations.initMocks(this);
-
-        mTutorialHandler = new OneHandedTutorialHandler(mContext, mMainExecutor);
         mOneHandedAnimationController = new OneHandedAnimationController(mContext);
     }
 

libs/WindowManager/Shell/tests/unittest/src/com/android/wm/shell/onehanded/OneHandedBackgroundPanelOrganizerTest.java

@@ -59,7 +59,7 @@ public class OneHandedBackgroundPanelOrganizerTest extends OneHandedTestCase {
     DisplayController mMockDisplayController;
 
     @Before
-    public void setUp() throws Exception {
+    public void setUp() {
         MockitoAnnotations.initMocks(this);
         mTestableLooper = TestableLooper.get(this);
         mToken = new WindowContainerToken(mMockRealToken);
@@ -81,15 +81,6 @@ public class OneHandedBackgroundPanelOrganizerTest extends OneHandedTestCase {
         assertThat(mBackgroundPanelOrganizer.getBackgroundSurface()).isNotNull();
     }
 
-    @Test
-    public void testUnregisterOrganizer() {
-        mBackgroundPanelOrganizer.onDisplayAreaAppeared(mDisplayAreaInfo, mLeash);
-        mTestableLooper.processAllMessages();
-        mBackgroundPanelOrganizer.unregisterOrganizer();
-
-        assertThat(mBackgroundPanelOrganizer.getBackgroundSurface()).isNull();
-    }
-
     @Test
     public void testShowBackgroundLayer() {
         mBackgroundPanelOrganizer.onDisplayAreaAppeared(mDisplayAreaInfo, mLeash);

libs/WindowManager/Shell/tests/unittest/src/com/android/wm/shell/onehanded/OneHandedControllerTest.java

@@ -16,19 +16,24 @@
 
 package com.android.wm.shell.onehanded;
 
+import static android.window.DisplayAreaOrganizer.FEATURE_ONE_HANDED;
+
 import static com.google.common.truth.Truth.assertThat;
 
+import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.anyInt;
 import static org.mockito.Mockito.atLeastOnce;
 import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.spy;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
 import android.content.om.IOverlayManager;
 import android.os.Handler;
-import android.provider.Settings;
 import android.testing.AndroidTestingRunner;
+import android.util.ArrayMap;
 import android.view.Display;
+import android.view.SurfaceControl;
 
 import androidx.test.filters.SmallTest;
 
@@ -37,19 +42,17 @@ import com.android.wm.shell.common.ShellExecutor;
 import com.android.wm.shell.common.TaskStackListenerImpl;
 
 import org.junit.Before;
-import org.junit.Ignore;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.Mock;
-import org.mockito.Mockito;
 import org.mockito.MockitoAnnotations;
 
 @SmallTest
 @RunWith(AndroidTestingRunner.class)
 public class OneHandedControllerTest extends OneHandedTestCase {
     Display mDisplay;
-    OneHandedController mOneHandedController;
+    OneHandedController mSpiedOneHandedController;
-    OneHandedTimeoutHandler mTimeoutHandler;
+    OneHandedTimeoutHandler mSpiedTimeoutHandler;
 
     @Mock
     DisplayController mMockDisplayController;
@@ -64,8 +67,6 @@ public class OneHandedControllerTest extends OneHandedTestCase {
     @Mock
     OneHandedGestureHandler mMockGestureHandler;
     @Mock
-    OneHandedTimeoutHandler mMockTimeoutHandler;
-    @Mock
     OneHandedUiEventLogger mMockUiEventLogger;
     @Mock
     IOverlayManager mMockOverlayManager;
@@ -74,14 +75,28 @@ public class OneHandedControllerTest extends OneHandedTestCase {
     @Mock
     ShellExecutor mMockShellMainExecutor;
     @Mock
+    SurfaceControl mMockLeash;
+    @Mock
     Handler mMockShellMainHandler;
 
+    final boolean mDefaultEnabled = OneHandedSettingsUtil.getSettingsOneHandedModeEnabled(
+            getTestContext().getContentResolver());
+    final boolean mDefaultSwipeToNotificationEnabled =
+            OneHandedSettingsUtil.getSettingsSwipeToNotificationEnabled(
+                    getTestContext().getContentResolver());
+
     @Before
-    public void setUp() throws Exception {
+    public void setUp() {
         MockitoAnnotations.initMocks(this);
         mDisplay = mContext.getDisplay();
-        mTimeoutHandler = Mockito.spy(new OneHandedTimeoutHandler(mMockShellMainExecutor));
+        mSpiedTimeoutHandler = spy(new OneHandedTimeoutHandler(mMockShellMainExecutor));
-        OneHandedController oneHandedController = new OneHandedController(
+
+        when(mMockDisplayController.getDisplay(anyInt())).thenReturn(mDisplay);
+        when(mMockDisplayAreaOrganizer.isInOneHanded()).thenReturn(false);
+        when(mMockDisplayAreaOrganizer.getDisplayAreaTokenMap()).thenReturn(new ArrayMap<>());
+        when(mMockBackgroundOrganizer.getBackgroundSurface()).thenReturn(mMockLeash);
+
+        mSpiedOneHandedController = spy(new OneHandedController(
                 mContext,
                 mMockDisplayController,
                 mMockBackgroundOrganizer,
@@ -89,16 +104,13 @@ public class OneHandedControllerTest extends OneHandedTestCase {
                 mMockTouchHandler,
                 mMockTutorialHandler,
                 mMockGestureHandler,
-                mTimeoutHandler,
+                mSpiedTimeoutHandler,
                 mMockUiEventLogger,
                 mMockOverlayManager,
                 mMockTaskStackListener,
                 mMockShellMainExecutor,
-                mMockShellMainHandler);
+                mMockShellMainHandler)
-        mOneHandedController = Mockito.spy(oneHandedController);
+        );
-
-        when(mMockDisplayController.getDisplay(anyInt())).thenReturn(mDisplay);
-        when(mMockDisplayAreaOrganizer.isInOneHanded()).thenReturn(false);
     }
 
     @Test
@@ -113,21 +125,36 @@ public class OneHandedControllerTest extends OneHandedTestCase {
     }
 
     @Test
-    public void testRegisterOrganizer() {
+    public void testNoRegisterAndUnregisterInSameCall() {
-        verify(mMockDisplayAreaOrganizer, atLeastOnce()).registerOrganizer(anyInt());
+        if (mDefaultEnabled) {
+            verify(mMockDisplayAreaOrganizer, never()).unregisterOrganizer();
+        } else {
+            verify(mMockDisplayAreaOrganizer, never()).registerOrganizer(FEATURE_ONE_HANDED);
+        }
     }
 
     @Test
-    public void testStartOneHanded() {
+    public void testStartOneHandedShouldTriggerScheduleOffset() {
-        mOneHandedController.startOneHanded();
+        when(mMockDisplayAreaOrganizer.isInOneHanded()).thenReturn(false);
+        mSpiedOneHandedController.setOneHandedEnabled(true);
+        mSpiedOneHandedController.startOneHanded();
 
         verify(mMockDisplayAreaOrganizer).scheduleOffset(anyInt(), anyInt());
     }
 
+    @Test
+    public void testStartOneHandedShouldNotTriggerScheduleOffset() {
+        mSpiedOneHandedController.setOneHandedEnabled(true);
+        when(mMockDisplayAreaOrganizer.isInOneHanded()).thenReturn(true);
+        mSpiedOneHandedController.startOneHanded();
+
+        verify(mMockDisplayAreaOrganizer, never()).scheduleOffset(anyInt(), anyInt());
+    }
+
     @Test
     public void testStopOneHanded() {
         when(mMockDisplayAreaOrganizer.isInOneHanded()).thenReturn(false);
-        mOneHandedController.stopOneHanded();
+        mSpiedOneHandedController.stopOneHanded();
 
         verify(mMockDisplayAreaOrganizer, never()).scheduleOffset(anyInt(), anyInt());
     }
@@ -141,71 +168,66 @@ public class OneHandedControllerTest extends OneHandedTestCase {
 
     @Test
     public void testRegisterTransitionCallback() {
-        OneHandedTransitionCallback callback = new OneHandedTransitionCallback() {};
+        OneHandedTransitionCallback callback = new OneHandedTransitionCallback() {
-        mOneHandedController.registerTransitionCallback(callback);
+        };
+        mSpiedOneHandedController.registerTransitionCallback(callback);
 
         verify(mMockDisplayAreaOrganizer).registerTransitionCallback(callback);
     }
 
-
     @Test
     public void testStopOneHanded_shouldRemoveTimer() {
-        mOneHandedController.stopOneHanded();
+        when(mMockDisplayAreaOrganizer.isInOneHanded()).thenReturn(true);
+        mSpiedOneHandedController.stopOneHanded();
 
-        verify(mTimeoutHandler).removeTimer();
+        verify(mSpiedTimeoutHandler, atLeastOnce()).removeTimer();
     }
 
     @Test
-    public void testUpdateIsEnabled() {
+    public void testUpdateEnabled() {
-        final boolean enabled = true;
+        mSpiedOneHandedController.setOneHandedEnabled(true);
-        mOneHandedController.setOneHandedEnabled(enabled);
 
-        verify(mMockTouchHandler, atLeastOnce()).onOneHandedEnabled(enabled);
+        verify(mMockTouchHandler, atLeastOnce()).onOneHandedEnabled(mDefaultEnabled);
+        verify(mMockGestureHandler, atLeastOnce()).onOneHandedEnabled(
+                mDefaultEnabled || mDefaultSwipeToNotificationEnabled);
     }
 
     @Test
-    public void testUpdateSwipeToNotificationIsEnabled() {
+    public void testUpdateSwipeToNotificationEnabled() {
-        final boolean enabled = true;
+        final boolean swipeToNotificationEnabled = true;
-        mOneHandedController.setSwipeToNotificationEnabled(enabled);
+        mSpiedOneHandedController.setSwipeToNotificationEnabled(swipeToNotificationEnabled);
 
-        verify(mMockTouchHandler, atLeastOnce()).onOneHandedEnabled(enabled);
+        verify(mMockTouchHandler, atLeastOnce()).onOneHandedEnabled(mDefaultEnabled);
+        verify(mMockGestureHandler, atLeastOnce()).onOneHandedEnabled(
+                mDefaultEnabled || swipeToNotificationEnabled);
     }
 
-    @Ignore("b/167943723, refactor it and fix it")
     @Test
-    public void tesSettingsObserver_updateTapAppToExit() {
+    public void testUpdateTapAppToExitUpdate() {
-        Settings.Secure.putInt(mContext.getContentResolver(),
+        mSpiedOneHandedController.onTaskChangeExitSettingChanged();
-                Settings.Secure.TAPS_APP_TO_EXIT, 1);
 
-        verify(mOneHandedController).setTaskChangeToExit(true);
+        verify(mMockTaskStackListener, atLeastOnce()).addListener(any());
     }
 
-    @Ignore("b/167943723, refactor it and fix it")
     @Test
-    public void tesSettingsObserver_updateEnabled() {
+    public void tesSettingsObserverUpdateEnabled() {
-        Settings.Secure.putInt(mContext.getContentResolver(),
+        mSpiedOneHandedController.onEnabledSettingChanged();
-                Settings.Secure.ONE_HANDED_MODE_ENABLED, 1);
 
-        verify(mOneHandedController).setOneHandedEnabled(true);
+        verify(mSpiedOneHandedController, atLeastOnce()).setOneHandedEnabled(mDefaultEnabled);
     }
 
-    @Ignore("b/167943723, refactor it and fix it")
     @Test
-    public void tesSettingsObserver_updateTimeout() {
+    public void testSettingsObserverUpdateTimeout() {
-        Settings.Secure.putInt(mContext.getContentResolver(),
+        mSpiedOneHandedController.onTimeoutSettingChanged();
-                Settings.Secure.ONE_HANDED_MODE_TIMEOUT,
-                OneHandedSettingsUtil.ONE_HANDED_TIMEOUT_MEDIUM_IN_SECONDS);
 
-        verify(mMockTimeoutHandler).setTimeout(
+        verify(mSpiedTimeoutHandler, atLeastOnce()).setTimeout(anyInt());
-                OneHandedSettingsUtil.ONE_HANDED_TIMEOUT_MEDIUM_IN_SECONDS);
     }
 
-    @Ignore("b/167943723, refactor it and fix it")
     @Test
-    public void tesSettingsObserver_updateSwipeToNotification() {
+    public void tesSettingsObserverUpdateSwipeToNotification() {
-        Settings.Secure.putInt(mContext.getContentResolver(),
+        mSpiedOneHandedController.onSwipeToNotificationEnabledSettingChanged();
-                Settings.Secure.SWIPE_BOTTOM_TO_NOTIFICATION_ENABLED, 1);
 
-        verify(mOneHandedController).setSwipeToNotificationEnabled(true);
+        verify(mSpiedOneHandedController, atLeastOnce()).setSwipeToNotificationEnabled(
+                !mDefaultEnabled);
     }
 }

libs/WindowManager/Shell/tests/unittest/src/com/android/wm/shell/onehanded/OneHandedDisplayAreaOrganizerTest.java

@@ -27,6 +27,7 @@ import static org.mockito.Mockito.any;
 import static org.mockito.Mockito.doReturn;
 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;
 
@@ -37,6 +38,7 @@ import android.testing.TestableLooper;
 import android.view.Display;
 import android.view.Surface;
 import android.view.SurfaceControl;
+import android.window.DisplayAreaAppearedInfo;
 import android.window.DisplayAreaInfo;
 import android.window.IWindowContainerToken;
 import android.window.WindowContainerToken;
@@ -53,15 +55,19 @@ import org.junit.runner.RunWith;
 import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
 
+import java.util.ArrayList;
+import java.util.List;
+
 @SmallTest
 @RunWith(AndroidTestingRunner.class)
 public class OneHandedDisplayAreaOrganizerTest extends OneHandedTestCase {
+    static final int DISPLAYAREA_INFO_COUNT = 3;
     static final int DISPLAY_WIDTH = 1000;
     static final int DISPLAY_HEIGHT = 1000;
 
     DisplayAreaInfo mDisplayAreaInfo;
     Display mDisplay;
-    OneHandedDisplayAreaOrganizer mDisplayAreaOrganizer;
+    OneHandedDisplayAreaOrganizer mSpiedDisplayAreaOrganizer;
     OneHandedTutorialHandler mTutorialHandler;
     OneHandedAnimationController.OneHandedTransitionAnimator mFakeAnimator;
     WindowContainerToken mToken;
@@ -86,6 +92,8 @@ public class OneHandedDisplayAreaOrganizerTest extends OneHandedTestCase {
     @Mock
     ShellExecutor mMockShellMainExecutor;
 
+    List<DisplayAreaAppearedInfo> mDisplayAreaAppearedInfoList = new ArrayList<>();
+
     @Before
     public void setUp() throws Exception {
         MockitoAnnotations.initMocks(this);
@@ -112,170 +120,195 @@ public class OneHandedDisplayAreaOrganizerTest extends OneHandedTestCase {
         when(mMockLeash.getWidth()).thenReturn(DISPLAY_WIDTH);
         when(mMockLeash.getHeight()).thenReturn(DISPLAY_HEIGHT);
 
-        mDisplayAreaOrganizer = spy(new OneHandedDisplayAreaOrganizer(mContext,
+        mSpiedDisplayAreaOrganizer = spy(new OneHandedDisplayAreaOrganizer(mContext,
                 mMockDisplayController,
                 mMockAnimationController,
                 mTutorialHandler,
                 mMockBackgroundOrganizer,
                 mMockShellMainExecutor));
+
+        for (int i = 0; i < DISPLAYAREA_INFO_COUNT; i++) {
+            mDisplayAreaAppearedInfoList.add(getDummyDisplayAreaInfo());
+        }
+        doReturn(mDisplayAreaAppearedInfoList).when(mSpiedDisplayAreaOrganizer).registerOrganizer(
+                FEATURE_ONE_HANDED);
+    }
+
+    private DisplayAreaAppearedInfo getDummyDisplayAreaInfo() {
+        return new DisplayAreaAppearedInfo(mDisplayAreaInfo, mMockLeash);
+    }
+
+    @Test
+    public void testRegisterDisplayAreaOrganizer() {
+        assertThat(mSpiedDisplayAreaOrganizer.registerOrganizer(FEATURE_ONE_HANDED)).isNotNull();
     }
 
     @Test
     public void testOnDisplayAreaAppeared() {
-        mDisplayAreaOrganizer.onDisplayAreaAppeared(mDisplayAreaInfo, mLeash);
+        mDisplayAreaAppearedInfoList.forEach(
+                (info) -> mSpiedDisplayAreaOrganizer.onDisplayAreaAppeared(
+                        info.getDisplayAreaInfo(),
+                        info.getLeash()));
 
         verify(mMockAnimationController, never()).getAnimator(any(), any(), any(), any());
     }
 
     @Test
     public void testOnDisplayAreaVanished() {
-        mDisplayAreaOrganizer.onDisplayAreaAppeared(mDisplayAreaInfo, mLeash);
+        mDisplayAreaAppearedInfoList.forEach(
-        mDisplayAreaOrganizer.onDisplayAreaVanished(mDisplayAreaInfo);
+                (info) -> mSpiedDisplayAreaOrganizer.onDisplayAreaAppeared(
+                        info.getDisplayAreaInfo(),
+                        info.getLeash()));
 
-        assertThat(mDisplayAreaOrganizer.mDisplayAreaTokenMap).isEmpty();
+        mDisplayAreaAppearedInfoList.forEach(
+                (info) -> mSpiedDisplayAreaOrganizer.onDisplayAreaVanished(
+                        info.getDisplayAreaInfo()));
+
+        verify(mSpiedDisplayAreaOrganizer, times(DISPLAYAREA_INFO_COUNT)).onDisplayAreaVanished(
+                any());
     }
 
     @Test
     public void testRotation_portrait_0_to_landscape_90() {
         when(mMockLeash.isValid()).thenReturn(false);
         // Rotate 0 -> 90
-        mDisplayAreaOrganizer.onRotateDisplay(Surface.ROTATION_0, Surface.ROTATION_90,
+        mSpiedDisplayAreaOrganizer.onRotateDisplay(Surface.ROTATION_0, Surface.ROTATION_90,
                 mMockWindowContainerTransaction);
-        verify(mDisplayAreaOrganizer).finishOffset(anyInt(), anyInt());
+        verify(mSpiedDisplayAreaOrganizer).finishOffset(anyInt(), anyInt());
     }
 
     @Test
     public void testRotation_portrait_0_to_seascape_270() {
         when(mMockLeash.isValid()).thenReturn(false);
         // Rotate 0 -> 270
-        mDisplayAreaOrganizer.onRotateDisplay(Surface.ROTATION_0, Surface.ROTATION_270,
+        mSpiedDisplayAreaOrganizer.onRotateDisplay(Surface.ROTATION_0, Surface.ROTATION_270,
                 mMockWindowContainerTransaction);
-        verify(mDisplayAreaOrganizer).finishOffset(anyInt(), anyInt());
+        verify(mSpiedDisplayAreaOrganizer).finishOffset(anyInt(), anyInt());
     }
 
     @Test
     public void testRotation_portrait_180_to_landscape_90() {
         when(mMockLeash.isValid()).thenReturn(false);
         // Rotate 180 -> 90
-        mDisplayAreaOrganizer.onRotateDisplay(Surface.ROTATION_180, Surface.ROTATION_90,
+        mSpiedDisplayAreaOrganizer.onRotateDisplay(Surface.ROTATION_180, Surface.ROTATION_90,
                 mMockWindowContainerTransaction);
-        verify(mDisplayAreaOrganizer).finishOffset(anyInt(), anyInt());
+        verify(mSpiedDisplayAreaOrganizer).finishOffset(anyInt(), anyInt());
     }
 
     @Test
     public void testRotation_portrait_180_to_seascape_270() {
         when(mMockLeash.isValid()).thenReturn(false);
         // Rotate 180 -> 270
-        mDisplayAreaOrganizer.onRotateDisplay(Surface.ROTATION_180, Surface.ROTATION_270,
+        mSpiedDisplayAreaOrganizer.onRotateDisplay(Surface.ROTATION_180, Surface.ROTATION_270,
                 mMockWindowContainerTransaction);
-        verify(mDisplayAreaOrganizer).finishOffset(anyInt(), anyInt());
+        verify(mSpiedDisplayAreaOrganizer).finishOffset(anyInt(), anyInt());
     }
 
     @Test
     public void testRotation_landscape_90_to_portrait_0() {
         when(mMockLeash.isValid()).thenReturn(false);
         // Rotate 90 -> 0
-        mDisplayAreaOrganizer.onRotateDisplay(Surface.ROTATION_90, Surface.ROTATION_0,
+        mSpiedDisplayAreaOrganizer.onRotateDisplay(Surface.ROTATION_90, Surface.ROTATION_0,
                 mMockWindowContainerTransaction);
-        verify(mDisplayAreaOrganizer).finishOffset(anyInt(), anyInt());
+        verify(mSpiedDisplayAreaOrganizer).finishOffset(anyInt(), anyInt());
     }
 
     @Test
     public void testRotation_landscape_90_to_portrait_180() {
         when(mMockLeash.isValid()).thenReturn(false);
         // Rotate 90 -> 180
-        mDisplayAreaOrganizer.onRotateDisplay(Surface.ROTATION_90, Surface.ROTATION_180,
+        mSpiedDisplayAreaOrganizer.onRotateDisplay(Surface.ROTATION_90, Surface.ROTATION_180,
                 mMockWindowContainerTransaction);
-        verify(mDisplayAreaOrganizer).finishOffset(anyInt(), anyInt());
+        verify(mSpiedDisplayAreaOrganizer).finishOffset(anyInt(), anyInt());
     }
 
     @Test
     public void testRotation_Seascape_270_to_portrait_0() {
         when(mMockLeash.isValid()).thenReturn(false);
         // Rotate 270 -> 0
-        mDisplayAreaOrganizer.onRotateDisplay(Surface.ROTATION_270, Surface.ROTATION_0,
+        mSpiedDisplayAreaOrganizer.onRotateDisplay(Surface.ROTATION_270, Surface.ROTATION_0,
                 mMockWindowContainerTransaction);
-        verify(mDisplayAreaOrganizer).finishOffset(anyInt(), anyInt());
+        verify(mSpiedDisplayAreaOrganizer).finishOffset(anyInt(), anyInt());
     }
 
     @Test
     public void testRotation_seascape_90_to_portrait_180() {
         when(mMockLeash.isValid()).thenReturn(false);
         // Rotate 270 -> 180
-        mDisplayAreaOrganizer.onRotateDisplay(Surface.ROTATION_270, Surface.ROTATION_180,
+        mSpiedDisplayAreaOrganizer.onRotateDisplay(Surface.ROTATION_270, Surface.ROTATION_180,
                 mMockWindowContainerTransaction);
-        verify(mDisplayAreaOrganizer).finishOffset(anyInt(), anyInt());
+        verify(mSpiedDisplayAreaOrganizer).finishOffset(anyInt(), anyInt());
     }
 
     @Test
     public void testRotation_portrait_0_to_portrait_0() {
         when(mMockLeash.isValid()).thenReturn(false);
         // Rotate 0 -> 0
-        mDisplayAreaOrganizer.onRotateDisplay(Surface.ROTATION_0, Surface.ROTATION_0,
+        mSpiedDisplayAreaOrganizer.onRotateDisplay(Surface.ROTATION_0, Surface.ROTATION_0,
                 mMockWindowContainerTransaction);
-        verify(mDisplayAreaOrganizer, never()).finishOffset(anyInt(), anyInt());
+        verify(mSpiedDisplayAreaOrganizer, never()).finishOffset(anyInt(), anyInt());
     }
 
     @Test
     public void testRotation_portrait_0_to_portrait_180() {
         when(mMockLeash.isValid()).thenReturn(false);
         // Rotate 0 -> 180
-        mDisplayAreaOrganizer.onRotateDisplay(Surface.ROTATION_0, Surface.ROTATION_180,
+        mSpiedDisplayAreaOrganizer.onRotateDisplay(Surface.ROTATION_0, Surface.ROTATION_180,
                 mMockWindowContainerTransaction);
-        verify(mDisplayAreaOrganizer, never()).finishOffset(anyInt(), anyInt());
+        verify(mSpiedDisplayAreaOrganizer, never()).finishOffset(anyInt(), anyInt());
     }
 
     @Test
     public void testRotation_portrait_180_to_portrait_180() {
         when(mMockLeash.isValid()).thenReturn(false);
         // Rotate 180 -> 180
-        mDisplayAreaOrganizer.onRotateDisplay(Surface.ROTATION_180, Surface.ROTATION_180,
+        mSpiedDisplayAreaOrganizer.onRotateDisplay(Surface.ROTATION_180, Surface.ROTATION_180,
                 mMockWindowContainerTransaction);
-        verify(mDisplayAreaOrganizer, never()).finishOffset(anyInt(), anyInt());
+        verify(mSpiedDisplayAreaOrganizer, never()).finishOffset(anyInt(), anyInt());
     }
 
     @Test
     public void testRotation_portrait_180_to_portrait_0() {
         when(mMockLeash.isValid()).thenReturn(false);
         // Rotate 180 -> 0
-        mDisplayAreaOrganizer.onRotateDisplay(Surface.ROTATION_180, Surface.ROTATION_0,
+        mSpiedDisplayAreaOrganizer.onRotateDisplay(Surface.ROTATION_180, Surface.ROTATION_0,
                 mMockWindowContainerTransaction);
-        verify(mDisplayAreaOrganizer, never()).finishOffset(anyInt(), anyInt());
+        verify(mSpiedDisplayAreaOrganizer, never()).finishOffset(anyInt(), anyInt());
     }
 
     @Test
     public void testRotation_landscape_90_to_landscape_90() {
         when(mMockLeash.isValid()).thenReturn(false);
         // Rotate 90 -> 90
-        mDisplayAreaOrganizer.onRotateDisplay(Surface.ROTATION_90, Surface.ROTATION_90,
+        mSpiedDisplayAreaOrganizer.onRotateDisplay(Surface.ROTATION_90, Surface.ROTATION_90,
                 mMockWindowContainerTransaction);
-        verify(mDisplayAreaOrganizer, never()).finishOffset(anyInt(), anyInt());
+        verify(mSpiedDisplayAreaOrganizer, never()).finishOffset(anyInt(), anyInt());
     }
 
     @Test
     public void testRotation_landscape_90_to_seascape_270() {
         when(mMockLeash.isValid()).thenReturn(false);
         // Rotate 90 -> 270
-        mDisplayAreaOrganizer.onRotateDisplay(Surface.ROTATION_90, Surface.ROTATION_270,
+        mSpiedDisplayAreaOrganizer.onRotateDisplay(Surface.ROTATION_90, Surface.ROTATION_270,
                 mMockWindowContainerTransaction);
-        verify(mDisplayAreaOrganizer, never()).finishOffset(anyInt(), anyInt());
+        verify(mSpiedDisplayAreaOrganizer, never()).finishOffset(anyInt(), anyInt());
     }
 
     @Test
     public void testRotation_seascape_270_to_seascape_270() {
         when(mMockLeash.isValid()).thenReturn(false);
         // Rotate 270 -> 270
-        mDisplayAreaOrganizer.onRotateDisplay(Surface.ROTATION_270, Surface.ROTATION_270,
+        mSpiedDisplayAreaOrganizer.onRotateDisplay(Surface.ROTATION_270, Surface.ROTATION_270,
                 mMockWindowContainerTransaction);
-        verify(mDisplayAreaOrganizer, never()).finishOffset(anyInt(), anyInt());
+        verify(mSpiedDisplayAreaOrganizer, never()).finishOffset(anyInt(), anyInt());
     }
 
     @Test
     public void testRotation_seascape_90_to_landscape_90() {
         when(mMockLeash.isValid()).thenReturn(false);
         // Rotate 270 -> 90
-        mDisplayAreaOrganizer.onRotateDisplay(Surface.ROTATION_270, Surface.ROTATION_90,
+        mSpiedDisplayAreaOrganizer.onRotateDisplay(Surface.ROTATION_270, Surface.ROTATION_90,
                 mMockWindowContainerTransaction);
-        verify(mDisplayAreaOrganizer, never()).finishOffset(anyInt(), anyInt());
+        verify(mSpiedDisplayAreaOrganizer, never()).finishOffset(anyInt(), anyInt());
     }
 }

libs/WindowManager/Shell/tests/unittest/src/com/android/wm/shell/onehanded/OneHandedGestureHandlerTest.java

@@ -18,10 +18,8 @@ package com.android.wm.shell.onehanded;
 
 import static com.google.common.truth.Truth.assertThat;
 
-import static org.mockito.ArgumentMatchers.any;
-
 import android.testing.AndroidTestingRunner;
-import android.testing.TestableLooper;
+import android.view.ViewConfiguration;
 
 import androidx.test.filters.SmallTest;
 
@@ -29,7 +27,6 @@ import com.android.wm.shell.common.DisplayController;
 import com.android.wm.shell.common.ShellExecutor;
 
 import org.junit.Before;
-import org.junit.Ignore;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.Mock;
@@ -38,7 +35,6 @@ import org.mockito.MockitoAnnotations;
 @SmallTest
 @RunWith(AndroidTestingRunner.class)
 public class OneHandedGestureHandlerTest extends OneHandedTestCase {
-    OneHandedTutorialHandler mTutorialHandler;
     OneHandedGestureHandler mGestureHandler;
     @Mock
     DisplayController mMockDisplayController;
@@ -46,11 +42,10 @@ public class OneHandedGestureHandlerTest extends OneHandedTestCase {
     ShellExecutor mMockShellMainExecutor;
 
     @Before
-    public void setUp() throws Exception {
+    public void setUp() {
         MockitoAnnotations.initMocks(this);
-        mTutorialHandler = new OneHandedTutorialHandler(mContext, mMockShellMainExecutor);
         mGestureHandler = new OneHandedGestureHandler(mContext, mMockDisplayController,
-                mMockShellMainExecutor);
+                ViewConfiguration.get(mTestContext), mMockShellMainExecutor);
     }
 
     @Test
@@ -68,16 +63,6 @@ public class OneHandedGestureHandlerTest extends OneHandedTestCase {
         assertThat(mGestureHandler.mGestureEventCallback).isEqualTo(callback);
     }
 
-    @Ignore("b/167943723, refactor it and fix it")
-    @Test
-    public void testReceiveNewConfig_whenThreeButtonModeEnabled() {
-        mGestureHandler.onOneHandedEnabled(true);
-        mGestureHandler.onThreeButtonModeEnabled(true);
-
-        assertThat(mGestureHandler.mInputMonitor).isNotNull();
-        assertThat(mGestureHandler.mInputEventReceiver).isNotNull();
-    }
-
     @Test
     public void testOneHandedDisabled_shouldDisposeInputChannel() {
         mGestureHandler.onOneHandedEnabled(false);

libs/WindowManager/Shell/tests/unittest/src/com/android/wm/shell/onehanded/OneHandedSettingsUtilTest.java

@@ -28,7 +28,6 @@ import android.database.ContentObserver;
 import android.net.Uri;
 import android.provider.Settings;
 import android.testing.AndroidTestingRunner;
-import android.testing.TestableLooper;
 
 import androidx.test.filters.SmallTest;
 

libs/WindowManager/Shell/tests/unittest/src/com/android/wm/shell/onehanded/OneHandedTestCase.java

@@ -19,88 +19,47 @@ package com.android.wm.shell.onehanded;
 import static android.view.Display.DEFAULT_DISPLAY;
 
 import static com.android.wm.shell.onehanded.OneHandedController.SUPPORT_ONE_HANDED_MODE;
-import static com.android.wm.shell.onehanded.OneHandedSettingsUtil.ONE_HANDED_TIMEOUT_MEDIUM_IN_SECONDS;
 
 import static org.junit.Assume.assumeTrue;
 
 import android.content.Context;
 import android.hardware.display.DisplayManager;
 import android.os.SystemProperties;
-import android.provider.Settings;
+import android.testing.TestableContext;
 
 import androidx.test.platform.app.InstrumentationRegistry;
 
-import org.junit.After;
 import org.junit.Before;
+import org.junit.Rule;
+import org.mockito.Answers;
+import org.mockito.Mock;
 
 /**
  * Base class that does One Handed specific setup.
  */
 public abstract class OneHandedTestCase {
-    static boolean sOrigEnabled;
+    @Mock(answer = Answers.RETURNS_DEEP_STUBS)
-    static boolean sOrigTapsAppToExitEnabled;
-    static int sOrigTimeout;
-    static boolean sOrigSwipeToNotification;
-
     protected Context mContext;
 
+    @Rule
+    public TestableContext mTestContext = new TestableContext(
+            InstrumentationRegistry.getInstrumentation().getTargetContext(), null);
+
     @Before
-    public void setupSettings() {
+    public void setUpContext() {
         assumeTrue(SystemProperties.getBoolean(SUPPORT_ONE_HANDED_MODE, false));
 
-        final Context testContext =
+        final DisplayManager dm = getTestContext().getSystemService(DisplayManager.class);
-                InstrumentationRegistry.getInstrumentation().getTargetContext();
+        mContext = getTestContext().createDisplayContext(dm.getDisplay(DEFAULT_DISPLAY));
-        final DisplayManager dm = testContext.getSystemService(DisplayManager.class);
-        mContext = testContext.createDisplayContext(dm.getDisplay(DEFAULT_DISPLAY));
-
-        InstrumentationRegistry
-                .getInstrumentation()
-                .getUiAutomation()
-                .adoptShellPermissionIdentity();
-
-        sOrigEnabled = OneHandedSettingsUtil.getSettingsOneHandedModeEnabled(
-                getContext().getContentResolver());
-        sOrigTimeout = OneHandedSettingsUtil.getSettingsOneHandedModeTimeout(
-                getContext().getContentResolver());
-        sOrigTapsAppToExitEnabled = OneHandedSettingsUtil.getSettingsTapsAppToExit(
-                getContext().getContentResolver());
-        sOrigSwipeToNotification = OneHandedSettingsUtil.getSettingsSwipeToNotificationEnabled(
-                getContext().getContentResolver());
-        Settings.Secure.putInt(getContext().getContentResolver(),
-                Settings.Secure.ONE_HANDED_MODE_ENABLED, 1);
-        Settings.Secure.putInt(getContext().getContentResolver(),
-                Settings.Secure.ONE_HANDED_MODE_TIMEOUT, ONE_HANDED_TIMEOUT_MEDIUM_IN_SECONDS);
-        Settings.Secure.putInt(getContext().getContentResolver(),
-                Settings.Secure.TAPS_APP_TO_EXIT, 1);
-        Settings.Secure.putInt(getContext().getContentResolver(),
-                Settings.Secure.SWIPE_BOTTOM_TO_NOTIFICATION_ENABLED, 1);
     }
 
-    @After
+    /** return testable context */
-    public void restoreSettings() {
+    protected TestableContext getTestContext() {
-        if (mContext == null) {
+        return mTestContext;
-            // Return early if one-handed mode is not supported
-            return;
-        }
-
-        Settings.Secure.putInt(getContext().getContentResolver(),
-                Settings.Secure.ONE_HANDED_MODE_ENABLED, sOrigEnabled ? 1 : 0);
-        Settings.Secure.putInt(mContext.getContentResolver(),
-                Settings.Secure.ONE_HANDED_MODE_TIMEOUT, sOrigTimeout);
-        Settings.Secure.putInt(mContext.getContentResolver(),
-                Settings.Secure.TAPS_APP_TO_EXIT, sOrigTapsAppToExitEnabled ? 1 : 0);
-        Settings.Secure.putInt(mContext.getContentResolver(),
-                Settings.Secure.SWIPE_BOTTOM_TO_NOTIFICATION_ENABLED,
-                sOrigSwipeToNotification ? 1 : 0);
-
-        InstrumentationRegistry
-                .getInstrumentation()
-                .getUiAutomation()
-                .dropShellPermissionIdentity();
     }
 
+    /** return display context */
     protected Context getContext() {
         return mContext;
     }
 }
-

libs/WindowManager/Shell/tests/unittest/src/com/android/wm/shell/onehanded/OneHandedTimeoutHandlerTest.java

@@ -27,24 +27,18 @@ import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
 import static org.mockito.Mockito.verify;
 
-import android.os.Looper;
 import android.testing.AndroidTestingRunner;
-import android.testing.TestableLooper;
 
 import androidx.test.filters.SmallTest;
 
 import com.android.wm.shell.TestShellExecutor;
-import com.android.wm.shell.common.ShellExecutor;
 
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
-import org.mockito.Mock;
 import org.mockito.Mockito;
 import org.mockito.MockitoAnnotations;
 
-import java.util.ArrayList;
-
 @SmallTest
 @RunWith(AndroidTestingRunner.class)
 public class OneHandedTimeoutHandlerTest extends OneHandedTestCase {
@@ -52,7 +46,7 @@ public class OneHandedTimeoutHandlerTest extends OneHandedTestCase {
     private TestShellExecutor mMainExecutor;
 
     @Before
-    public void setUp() throws Exception {
+    public void setUp() {
         MockitoAnnotations.initMocks(this);
         mMainExecutor = new TestShellExecutor();
         mTimeoutHandler = Mockito.spy(new OneHandedTimeoutHandler(mMainExecutor));

libs/WindowManager/Shell/tests/unittest/src/com/android/wm/shell/onehanded/OneHandedTouchHandlerTest.java

@@ -18,8 +18,9 @@ package com.android.wm.shell.onehanded;
 
 import static com.google.common.truth.Truth.assertThat;
 
+import static org.mockito.Mockito.spy;
+
 import android.testing.AndroidTestingRunner;
-import android.testing.TestableLooper;
 
 import androidx.test.filters.SmallTest;
 
@@ -35,18 +36,20 @@ import org.mockito.MockitoAnnotations;
 @SmallTest
 @RunWith(AndroidTestingRunner.class)
 public class OneHandedTouchHandlerTest extends OneHandedTestCase {
+    boolean mIsEventCallback = false;
+
     private OneHandedTouchHandler mTouchHandler;
-
+    private OneHandedTimeoutHandler mSpiedTimeoutHandler;
+    private OneHandedTouchHandler.OneHandedTouchEventCallback mTouchEventCallback =
+            () -> mIsEventCallback = true;
     @Mock
-    private OneHandedTimeoutHandler mTimeoutHandler;
+    private ShellExecutor mMockShellMainExecutor;
-
-    @Mock
-    private ShellExecutor mMainExecutor;
 
     @Before
     public void setUp() {
         MockitoAnnotations.initMocks(this);
-        mTouchHandler = new OneHandedTouchHandler(mTimeoutHandler, mMainExecutor);
+        mSpiedTimeoutHandler = spy(new OneHandedTimeoutHandler(mMockShellMainExecutor));
+        mTouchHandler = new OneHandedTouchHandler(mSpiedTimeoutHandler, mMockShellMainExecutor);
     }
 
     @Test
@@ -55,7 +58,7 @@ public class OneHandedTouchHandlerTest extends OneHandedTestCase {
         };
         mTouchHandler.registerTouchEventListener(callback);
 
-        assertThat(mTouchHandler.mTouchEventCallback).isEqualTo(callback);
+        assertThat(mIsEventCallback).isFalse();
     }
 
     @Test

libs/WindowManager/Shell/tests/unittest/src/com/android/wm/shell/onehanded/OneHandedTutorialHandlerTest.java

@@ -17,10 +17,12 @@
 package com.android.wm.shell.onehanded;
 
 import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
 
 import android.content.om.IOverlayManager;
 import android.os.Handler;
 import android.testing.AndroidTestingRunner;
+import android.util.ArrayMap;
 
 import androidx.test.filters.SmallTest;
 
@@ -37,12 +39,15 @@ import org.mockito.MockitoAnnotations;
 @SmallTest
 @RunWith(AndroidTestingRunner.class)
 public class OneHandedTutorialHandlerTest extends OneHandedTestCase {
-    @Mock
-    OneHandedTouchHandler mTouchHandler;
-    OneHandedTutorialHandler mTutorialHandler;
-    OneHandedGestureHandler mGestureHandler;
     OneHandedTimeoutHandler mTimeoutHandler;
     OneHandedController mOneHandedController;
+
+    @Mock
+    OneHandedGestureHandler mMockGestureHandler;
+    @Mock
+    OneHandedTouchHandler mMockTouchHandler;
+    @Mock
+    OneHandedTutorialHandler mMockTutorialHandler;
     @Mock
     DisplayController mMockDisplayController;
     @Mock
@@ -64,18 +69,17 @@ public class OneHandedTutorialHandlerTest extends OneHandedTestCase {
     @Before
     public void setUp() {
         MockitoAnnotations.initMocks(this);
-        mTutorialHandler = new OneHandedTutorialHandler(mContext, mMockShellMainExecutor);
         mTimeoutHandler = new OneHandedTimeoutHandler(mMockShellMainExecutor);
-        mGestureHandler = new OneHandedGestureHandler(mContext, mMockDisplayController,
+
-                mMockShellMainExecutor);
+        when(mMockDisplayAreaOrganizer.getDisplayAreaTokenMap()).thenReturn(new ArrayMap<>());
         mOneHandedController = new OneHandedController(
                 getContext(),
                 mMockDisplayController,
                 mMockBackgroundOrganizer,
                 mMockDisplayAreaOrganizer,
-                mTouchHandler,
+                mMockTouchHandler,
-                mTutorialHandler,
+                mMockTutorialHandler,
-                mGestureHandler,
+                mMockGestureHandler,
                 mTimeoutHandler,
                 mMockUiEventLogger,
                 mMockOverlayManager,
@@ -86,6 +90,6 @@ public class OneHandedTutorialHandlerTest extends OneHandedTestCase {
 
     @Test
     public void testRegisterForDisplayAreaOrganizer() {
-        verify(mMockDisplayAreaOrganizer).registerTransitionCallback(mTutorialHandler);
+        verify(mMockDisplayAreaOrganizer).registerTransitionCallback(mMockTutorialHandler);
     }
 }