diff --git a/packages/SystemUI/src/com/android/systemui/accessibility/WindowMagnification.java b/packages/SystemUI/src/com/android/systemui/accessibility/WindowMagnification.java index 33ce20686e665..794b9dd5b68b6 100644 --- a/packages/SystemUI/src/com/android/systemui/accessibility/WindowMagnification.java +++ b/packages/SystemUI/src/com/android/systemui/accessibility/WindowMagnification.java @@ -68,15 +68,15 @@ public class WindowMagnification extends CoreStartable implements WindowMagnifie private Configuration mLastConfiguration; private SysUiState mSysUiState; - private static class AnimationControllerSupplier extends - DisplayIdIndexSupplier { + private static class ControllerSupplier extends + DisplayIdIndexSupplier { private final Context mContext; private final Handler mHandler; private final WindowMagnifierCallback mWindowMagnifierCallback; private final SysUiState mSysUiState; - AnimationControllerSupplier(Context context, Handler handler, + ControllerSupplier(Context context, Handler handler, WindowMagnifierCallback windowMagnifierCallback, DisplayManager displayManager, SysUiState sysUiState) { super(displayManager); @@ -87,19 +87,19 @@ public class WindowMagnification extends CoreStartable implements WindowMagnifie } @Override - protected WindowMagnificationAnimationController createInstance(Display display) { + protected WindowMagnificationController createInstance(Display display) { final Context windowContext = mContext.createWindowContext(display, TYPE_ACCESSIBILITY_MAGNIFICATION_OVERLAY, /* options */ null); - final WindowMagnificationController controller = new WindowMagnificationController( + return new WindowMagnificationController( windowContext, - mHandler, new SfVsyncFrameCallbackProvider(), null, + mHandler, new WindowMagnificationAnimationController(windowContext), + new SfVsyncFrameCallbackProvider(), null, new SurfaceControl.Transaction(), mWindowMagnifierCallback, mSysUiState); - return new WindowMagnificationAnimationController(windowContext, controller); } } @VisibleForTesting - DisplayIdIndexSupplier mAnimationControllerSupplier; + DisplayIdIndexSupplier mMagnificationControllerSupplier; @Inject public WindowMagnification(Context context, @Main Handler mainHandler, @@ -113,7 +113,7 @@ public class WindowMagnification extends CoreStartable implements WindowMagnifie mModeSwitchesController = modeSwitchesController; mSysUiState = sysUiState; mOverviewProxyService = overviewProxyService; - mAnimationControllerSupplier = new AnimationControllerSupplier(context, + mMagnificationControllerSupplier = new ControllerSupplier(context, mHandler, this, context.getSystemService(DisplayManager.class), sysUiState); } @@ -121,8 +121,9 @@ public class WindowMagnification extends CoreStartable implements WindowMagnifie public void onConfigurationChanged(Configuration newConfig) { final int configDiff = newConfig.diff(mLastConfiguration); mLastConfiguration.setTo(newConfig); - mAnimationControllerSupplier.forEach( - animationController -> animationController.onConfigurationChanged(configDiff)); + mMagnificationControllerSupplier.forEach( + magnificationController -> magnificationController.onConfigurationChanged( + configDiff)); if (mModeSwitchesController != null) { mModeSwitchesController.onConfigurationChanged(configDiff); } @@ -143,10 +144,10 @@ public class WindowMagnification extends CoreStartable implements WindowMagnifie private void updateSysUiStateFlag() { //TODO(b/187510533): support multi-display once SysuiState supports it. - final WindowMagnificationAnimationController controller = - mAnimationControllerSupplier.valueAt(Display.DEFAULT_DISPLAY); + final WindowMagnificationController controller = + mMagnificationControllerSupplier.valueAt(Display.DEFAULT_DISPLAY); if (controller != null) { - controller.updateSysUiStateFlag(); + controller.updateSysUIStateFlag(); } else { // The instance is initialized when there is an IPC request. Considering // self-crash cases, we need to reset the flag in such situation. @@ -158,39 +159,39 @@ public class WindowMagnification extends CoreStartable implements WindowMagnifie @MainThread void enableWindowMagnification(int displayId, float scale, float centerX, float centerY, @Nullable IRemoteMagnificationAnimationCallback callback) { - final WindowMagnificationAnimationController windowMagnificationAnimationController = - mAnimationControllerSupplier.get(displayId); - if (windowMagnificationAnimationController != null) { - windowMagnificationAnimationController.enableWindowMagnification(scale, centerX, + final WindowMagnificationController windowMagnificationController = + mMagnificationControllerSupplier.get(displayId); + if (windowMagnificationController != null) { + windowMagnificationController.enableWindowMagnification(scale, centerX, centerY, callback); } } @MainThread void setScale(int displayId, float scale) { - final WindowMagnificationAnimationController windowMagnificationAnimationController = - mAnimationControllerSupplier.get(displayId); - if (windowMagnificationAnimationController != null) { - windowMagnificationAnimationController.setScale(scale); + final WindowMagnificationController windowMagnificationController = + mMagnificationControllerSupplier.get(displayId); + if (windowMagnificationController != null) { + windowMagnificationController.setScale(scale); } } @MainThread void moveWindowMagnifier(int displayId, float offsetX, float offsetY) { - final WindowMagnificationAnimationController windowMagnificationAnimationController = - mAnimationControllerSupplier.get(displayId); - if (windowMagnificationAnimationController != null) { - windowMagnificationAnimationController.moveWindowMagnifier(offsetX, offsetY); + final WindowMagnificationController windowMagnificationcontroller = + mMagnificationControllerSupplier.get(displayId); + if (windowMagnificationcontroller != null) { + windowMagnificationcontroller.moveWindowMagnifier(offsetX, offsetY); } } @MainThread void disableWindowMagnification(int displayId, @Nullable IRemoteMagnificationAnimationCallback callback) { - final WindowMagnificationAnimationController windowMagnificationAnimationController = - mAnimationControllerSupplier.get(displayId); - if (windowMagnificationAnimationController != null) { - windowMagnificationAnimationController.deleteWindowMagnification(callback); + final WindowMagnificationController windowMagnificationController = + mMagnificationControllerSupplier.get(displayId); + if (windowMagnificationController != null) { + windowMagnificationController.deleteWindowMagnification(callback); } } @@ -234,8 +235,8 @@ public class WindowMagnification extends CoreStartable implements WindowMagnifie @Override public void dump(FileDescriptor fd, PrintWriter pw, String[] args) { pw.println(TAG); - mAnimationControllerSupplier.forEach( - animationController -> animationController.dump(pw)); + mMagnificationControllerSupplier.forEach( + magnificationController -> magnificationController.dump(pw)); } private void setWindowMagnificationConnection() { diff --git a/packages/SystemUI/src/com/android/systemui/accessibility/WindowMagnificationAnimationController.java b/packages/SystemUI/src/com/android/systemui/accessibility/WindowMagnificationAnimationController.java index 8cb608f768eb1..1bfa9c1a2a513 100644 --- a/packages/SystemUI/src/com/android/systemui/accessibility/WindowMagnificationAnimationController.java +++ b/packages/SystemUI/src/com/android/systemui/accessibility/WindowMagnificationAnimationController.java @@ -19,6 +19,7 @@ package com.android.systemui.accessibility; import android.animation.Animator; import android.animation.ValueAnimator; import android.annotation.IntDef; +import android.annotation.NonNull; import android.annotation.Nullable; import android.annotation.UiContext; import android.content.Context; @@ -31,7 +32,6 @@ import android.view.animation.AccelerateInterpolator; import com.android.internal.annotations.VisibleForTesting; import com.android.systemui.R; -import java.io.PrintWriter; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; @@ -54,11 +54,11 @@ class WindowMagnificationAnimationController implements ValueAnimator.AnimatorUp // The window magnification is enabled. private static final int STATE_ENABLED = 1; // The window magnification is going to be disabled when the animation is end. - private static final int STATE_DISABLING = 2; + private static final int STATE_DISABLING = 2; // The animation is running for enabling the window magnification. private static final int STATE_ENABLING = 3; - private final WindowMagnificationController mController; + private WindowMagnificationController mController; private final ValueAnimator mValueAnimator; private final AnimationSpec mStartSpec = new AnimationSpec(); private final AnimationSpec mEndSpec = new AnimationSpec(); @@ -71,21 +71,22 @@ class WindowMagnificationAnimationController implements ValueAnimator.AnimatorUp @MagnificationState private int mState = STATE_DISABLED; - WindowMagnificationAnimationController(@UiContext Context context, - WindowMagnificationController controller) { - this(context, controller, newValueAnimator(context.getResources())); + WindowMagnificationAnimationController(@UiContext Context context) { + this(context, newValueAnimator(context.getResources())); } @VisibleForTesting - WindowMagnificationAnimationController(Context context, - WindowMagnificationController controller, ValueAnimator valueAnimator) { + WindowMagnificationAnimationController(Context context, ValueAnimator valueAnimator) { mContext = context; - mController = controller; mValueAnimator = valueAnimator; mValueAnimator.addUpdateListener(this); mValueAnimator.addListener(this); } + void setWindowMagnificationController(@NonNull WindowMagnificationController controller) { + mController = controller; + } + /** * Wraps {@link WindowMagnificationController#enableWindowMagnification(float, float, float)} * with transition animation. If the window magnification is not enabled, the scale will start @@ -105,6 +106,9 @@ class WindowMagnificationAnimationController implements ValueAnimator.AnimatorUp */ void enableWindowMagnification(float scale, float centerX, float centerY, @Nullable IRemoteMagnificationAnimationCallback animationCallback) { + if (mController == null) { + return; + } sendAnimationCallback(false); // Enable window magnification without animation immediately. if (animationCallback == null) { @@ -139,6 +143,9 @@ class WindowMagnificationAnimationController implements ValueAnimator.AnimatorUp } private void setupEnableAnimationSpecs(float scale, float centerX, float centerY) { + if (mController == null) { + return; + } final float currentScale = mController.getScale(); final float currentCenterX = mController.getCenterX(); final float currentCenterY = mController.getCenterY(); @@ -160,15 +167,9 @@ class WindowMagnificationAnimationController implements ValueAnimator.AnimatorUp } } - /** - * Wraps {@link WindowMagnificationController#setScale(float)}. If the animation is - * running, it has no effect. - */ - void setScale(float scale) { - if (mValueAnimator.isRunning()) { - return; - } - mController.setScale(scale); + /** Returns {@code true} if the animator is running. */ + boolean isAnimating() { + return mValueAnimator.isRunning(); } /** @@ -181,6 +182,9 @@ class WindowMagnificationAnimationController implements ValueAnimator.AnimatorUp */ void deleteWindowMagnification( @Nullable IRemoteMagnificationAnimationCallback animationCallback) { + if (mController == null) { + return; + } sendAnimationCallback(false); // Delete window magnification without animation. if (animationCallback == null) { @@ -206,25 +210,6 @@ class WindowMagnificationAnimationController implements ValueAnimator.AnimatorUp setState(STATE_DISABLING); } - /** - * Wraps {@link WindowMagnificationController#moveWindowMagnifier(float, float)}. If the - * animation is running, it has no effect. - * @param offsetX The amount in pixels to offset the window magnifier in the X direction, in - * current screen pixels. - * @param offsetY The amount in pixels to offset the window magnifier in the Y direction, in - * current screen pixels. - */ - void moveWindowMagnifier(float offsetX, float offsetY) { - if (mValueAnimator.isRunning()) { - return; - } - mController.moveWindowMagnifier(offsetX, offsetY); - } - - void onConfigurationChanged(int configDiff) { - mController.onConfigurationChanged(configDiff); - } - private void setState(@MagnificationState int state) { if (DEBUG) { Log.d(TAG, "setState from " + mState + " to " + state); @@ -239,7 +224,7 @@ class WindowMagnificationAnimationController implements ValueAnimator.AnimatorUp @Override public void onAnimationEnd(Animator animation, boolean isReverse) { - if (mEndAnimationCanceled) { + if (mEndAnimationCanceled || mController == null) { return; } if (Float.isNaN(mController.getScale())) { @@ -279,6 +264,9 @@ class WindowMagnificationAnimationController implements ValueAnimator.AnimatorUp @Override public void onAnimationUpdate(ValueAnimator animation) { + if (mController == null) { + return; + } final float fract = animation.getAnimatedFraction(); final float sentScale = mStartSpec.mScale + (mEndSpec.mScale - mStartSpec.mScale) * fract; final float centerX = @@ -288,14 +276,6 @@ class WindowMagnificationAnimationController implements ValueAnimator.AnimatorUp mController.enableWindowMagnification(sentScale, centerX, centerY); } - public void updateSysUiStateFlag() { - mController.updateSysUIStateFlag(); - } - - void dump(PrintWriter pw) { - mController.dump(pw); - } - private static ValueAnimator newValueAnimator(Resources resources) { final ValueAnimator valueAnimator = new ValueAnimator(); valueAnimator.setDuration( diff --git a/packages/SystemUI/src/com/android/systemui/accessibility/WindowMagnificationController.java b/packages/SystemUI/src/com/android/systemui/accessibility/WindowMagnificationController.java index b48def2b948c6..250700487b7f5 100644 --- a/packages/SystemUI/src/com/android/systemui/accessibility/WindowMagnificationController.java +++ b/packages/SystemUI/src/com/android/systemui/accessibility/WindowMagnificationController.java @@ -59,6 +59,7 @@ import android.view.WindowManagerGlobal; import android.view.WindowMetrics; import android.view.accessibility.AccessibilityNodeInfo; import android.view.accessibility.AccessibilityNodeInfo.AccessibilityAction; +import android.view.accessibility.IRemoteMagnificationAnimationCallback; import com.android.internal.annotations.VisibleForTesting; import com.android.internal.graphics.SfVsyncFrameCallbackProvider; @@ -133,6 +134,7 @@ class WindowMagnificationController implements View.OnTouchListener, SurfaceHold // The top Y of the system gesture rect at the bottom. Set to -1 if it is invalid. private int mSystemGestureTop = -1; + private final WindowMagnificationAnimationController mAnimationController; private final SfVsyncFrameCallbackProvider mSfVsyncFrameProvider; private final MagnificationGestureDetector mGestureDetector; private final int mBounceEffectDuration; @@ -148,11 +150,14 @@ class WindowMagnificationController implements View.OnTouchListener, SurfaceHold private MirrorWindowControl mMirrorWindowControl; WindowMagnificationController(@UiContext Context context, @NonNull Handler handler, + @NonNull WindowMagnificationAnimationController animationController, SfVsyncFrameCallbackProvider sfVsyncFrameProvider, MirrorWindowControl mirrorWindowControl, SurfaceControl.Transaction transaction, @NonNull WindowMagnifierCallback callback, SysUiState sysUiState) { mContext = context; mHandler = handler; + mAnimationController = animationController; + mAnimationController.setWindowMagnificationController(this); mSfVsyncFrameProvider = sfVsyncFrameProvider; mWindowMagnifierCallback = callback; mSysUiState = sysUiState; @@ -258,6 +263,19 @@ class WindowMagnificationController implements View.OnTouchListener, SurfaceHold return false; } + /** + * Wraps {@link WindowMagnificationController#deleteWindowMagnification()}} with transition + * animation. If the window magnification is enabling, it runs the animation in reverse. + * + * @param animationCallback Called when the transition is complete, the given arguments + * are as same as current values, or the transition is interrupted + * due to the new transition request. + */ + void deleteWindowMagnification( + @Nullable IRemoteMagnificationAnimationCallback animationCallback) { + mAnimationController.deleteWindowMagnification(animationCallback); + } + /** * Deletes the magnification window. */ @@ -692,6 +710,27 @@ class WindowMagnificationController implements View.OnTouchListener, SurfaceHold moveWindowMagnifier(xOffset, yOffset); } + /** + * Wraps {@link WindowMagnificationController#enableWindowMagnification(float, float, float)} + * with transition animation. If the window magnification is not enabled, the scale will start + * from 1.0 and the center won't be changed during the animation. If animator is + * {@code STATE_DISABLING}, the animation runs in reverse. + * + * @param scale The target scale, or {@link Float#NaN} to leave unchanged. + * @param centerX The screen-relative X coordinate around which to center, + * or {@link Float#NaN} to leave unchanged. + * @param centerY The screen-relative Y coordinate around which to center, + * or {@link Float#NaN} to leave unchanged. + * @param animationCallback Called when the transition is complete, the given arguments + * are as same as current values, or the transition is interrupted + * due to the new transition request. + */ + void enableWindowMagnification(float scale, float centerX, float centerY, + @Nullable IRemoteMagnificationAnimationCallback animationCallback) { + mAnimationController.enableWindowMagnification(scale, centerX, + centerY, animationCallback); + } + /** * Enables window magnification with specified parameters. If the given scale is less * than or equal to 1.0f, then @@ -732,7 +771,7 @@ class WindowMagnificationController implements View.OnTouchListener, SurfaceHold * @param scale the target scale, or {@link Float#NaN} to leave unchanged */ void setScale(float scale) { - if (!isWindowVisible() || mScale == scale) { + if (mAnimationController.isAnimating() || !isWindowVisible() || mScale == scale) { return; } enableWindowMagnification(scale, Float.NaN, Float.NaN); @@ -749,7 +788,7 @@ class WindowMagnificationController implements View.OnTouchListener, SurfaceHold * current screen pixels. */ void moveWindowMagnifier(float offsetX, float offsetY) { - if (mMirrorSurfaceView == null) { + if (mAnimationController.isAnimating() || mMirrorSurfaceView == null) { return; } if (updateMagnificationFramePosition((int) offsetX, (int) offsetY)) { diff --git a/packages/SystemUI/tests/src/com/android/systemui/accessibility/IWindowMagnificationConnectionTest.java b/packages/SystemUI/tests/src/com/android/systemui/accessibility/IWindowMagnificationConnectionTest.java index 77286b11f652e..326d902601378 100644 --- a/packages/SystemUI/tests/src/com/android/systemui/accessibility/IWindowMagnificationConnectionTest.java +++ b/packages/SystemUI/tests/src/com/android/systemui/accessibility/IWindowMagnificationConnectionTest.java @@ -64,7 +64,7 @@ public class IWindowMagnificationConnectionTest extends SysuiTestCase { @Mock private IWindowMagnificationConnectionCallback mConnectionCallback; @Mock - private WindowMagnificationAnimationController mWindowMagnificationAnimationController; + private WindowMagnificationController mWindowMagnificationController; @Mock private ModeSwitchesController mModeSwitchesController; @Mock @@ -89,7 +89,7 @@ public class IWindowMagnificationConnectionTest extends SysuiTestCase { mWindowMagnification = new WindowMagnification(getContext(), getContext().getMainThreadHandler(), mCommandQueue, mModeSwitchesController, mSysUiState, mOverviewProxyService); - mWindowMagnification.mAnimationControllerSupplier = new FakeAnimationControllerSupplier( + mWindowMagnification.mMagnificationControllerSupplier = new FakeControllerSupplier( mContext.getSystemService(DisplayManager.class)); mWindowMagnification.requestWindowMagnificationConnection(true); @@ -103,7 +103,7 @@ public class IWindowMagnificationConnectionTest extends SysuiTestCase { Float.NaN, mAnimationCallback); waitForIdleSync(); - verify(mWindowMagnificationAnimationController).enableWindowMagnification(eq(3.0f), + verify(mWindowMagnificationController).enableWindowMagnification(eq(3.0f), eq(Float.NaN), eq(Float.NaN), eq(mAnimationCallback)); } @@ -113,7 +113,7 @@ public class IWindowMagnificationConnectionTest extends SysuiTestCase { mAnimationCallback); waitForIdleSync(); - verify(mWindowMagnificationAnimationController).deleteWindowMagnification( + verify(mWindowMagnificationController).deleteWindowMagnification( mAnimationCallback); } @@ -122,7 +122,7 @@ public class IWindowMagnificationConnectionTest extends SysuiTestCase { mIWindowMagnificationConnection.setScale(TEST_DISPLAY, 3.0f); waitForIdleSync(); - verify(mWindowMagnificationAnimationController).setScale(3.0f); + verify(mWindowMagnificationController).setScale(3.0f); } @Test @@ -130,7 +130,7 @@ public class IWindowMagnificationConnectionTest extends SysuiTestCase { mIWindowMagnificationConnection.moveWindowMagnifier(TEST_DISPLAY, 100f, 200f); waitForIdleSync(); - verify(mWindowMagnificationAnimationController).moveWindowMagnifier(100f, 200f); + verify(mWindowMagnificationController).moveWindowMagnifier(100f, 200f); } @Test @@ -151,16 +151,16 @@ public class IWindowMagnificationConnectionTest extends SysuiTestCase { verify(mModeSwitchesController).removeButton(TEST_DISPLAY); } - private class FakeAnimationControllerSupplier extends - DisplayIdIndexSupplier { + private class FakeControllerSupplier extends + DisplayIdIndexSupplier { - FakeAnimationControllerSupplier(DisplayManager displayManager) { + FakeControllerSupplier(DisplayManager displayManager) { super(displayManager); } @Override - protected WindowMagnificationAnimationController createInstance(Display display) { - return mWindowMagnificationAnimationController; + protected WindowMagnificationController createInstance(Display display) { + return mWindowMagnificationController; } } } diff --git a/packages/SystemUI/tests/src/com/android/systemui/accessibility/WindowMagnificationAnimationControllerTest.java b/packages/SystemUI/tests/src/com/android/systemui/accessibility/WindowMagnificationAnimationControllerTest.java index 148c6ef0be536..854fc33d768dc 100644 --- a/packages/SystemUI/tests/src/com/android/systemui/accessibility/WindowMagnificationAnimationControllerTest.java +++ b/packages/SystemUI/tests/src/com/android/systemui/accessibility/WindowMagnificationAnimationControllerTest.java @@ -100,12 +100,13 @@ public class WindowMagnificationAnimationControllerTest extends SysuiTestCase { mInstrumentation = InstrumentationRegistry.getInstrumentation(); mWaitingAnimationPeriod = 2 * ANIMATION_DURATION_MS; mWaitIntermediateAnimationPeriod = ANIMATION_DURATION_MS / 2; + mWindowMagnificationAnimationController = new WindowMagnificationAnimationController( + mContext, newValueAnimator()); mController = new SpyWindowMagnificationController(mContext, mHandler, + mWindowMagnificationAnimationController, mSfVsyncFrameProvider, null, new SurfaceControl.Transaction(), mWindowMagnifierCallback, mSysUiState); mSpyController = mController.getSpyController(); - mWindowMagnificationAnimationController = new WindowMagnificationAnimationController( - mContext, mController, newValueAnimator()); } @After @@ -382,17 +383,6 @@ public class WindowMagnificationAnimationControllerTest extends SysuiTestCase { verify(mAnimationCallback).onResult(true); } - @Test - public void setScale_enabled_expectedScale() { - enableWindowMagnificationWithoutAnimation(); - - mInstrumentation.runOnMainSync( - () -> mWindowMagnificationAnimationController.setScale(DEFAULT_SCALE + 1)); - - verify(mSpyController).setScale(DEFAULT_SCALE + 1); - verifyFinalSpec(DEFAULT_SCALE + 1, DEFAULT_CENTER_X, DEFAULT_CENTER_Y); - } - @Test public void deleteWindowMagnification_enabled_expectedValuesAndInvokeCallback() throws RemoteException { @@ -508,26 +498,12 @@ public class WindowMagnificationAnimationControllerTest extends SysuiTestCase { enableWindowMagnificationWithoutAnimation(); mInstrumentation.runOnMainSync( - () -> mWindowMagnificationAnimationController.moveWindowMagnifier(100f, 200f)); + () -> mController.moveWindowMagnifier(100f, 200f)); verify(mSpyController).moveWindowMagnifier(100f, 200f); verifyFinalSpec(DEFAULT_SCALE, DEFAULT_CENTER_X + 100f, DEFAULT_CENTER_Y + 100f); } - @Test - public void onConfigurationChanged_passThrough() { - mWindowMagnificationAnimationController.onConfigurationChanged(100); - - verify(mSpyController).onConfigurationChanged(100); - } - - @Test - public void updateSysUiStateFlag_passThrough() { - mWindowMagnificationAnimationController.updateSysUiStateFlag(); - - verify(mSpyController).updateSysUIStateFlag(); - } - private void verifyFinalSpec(float expectedScale, float expectedCenterX, float expectedCenterY) { assertEquals(expectedScale, mController.getScale(), 0f); @@ -581,11 +557,12 @@ public class WindowMagnificationAnimationControllerTest extends SysuiTestCase { private WindowMagnificationController mSpyController; SpyWindowMagnificationController(Context context, Handler handler, + WindowMagnificationAnimationController animationController, SfVsyncFrameCallbackProvider sfVsyncFrameProvider, MirrorWindowControl mirrorWindowControl, SurfaceControl.Transaction transaction, WindowMagnifierCallback callback, SysUiState sysUiState) { - super(context, handler, sfVsyncFrameProvider, mirrorWindowControl, transaction, - callback, sysUiState); + super(context, handler, animationController, sfVsyncFrameProvider, mirrorWindowControl, + transaction, callback, sysUiState); mSpyController = Mockito.mock(WindowMagnificationController.class); } @@ -622,12 +599,6 @@ public class WindowMagnificationAnimationControllerTest extends SysuiTestCase { super.updateSysUIStateFlag(); mSpyController.updateSysUIStateFlag(); } - - @Override - void onConfigurationChanged(int configDiff) { - super.onConfigurationChanged(configDiff); - mSpyController.onConfigurationChanged(configDiff); - } } private static ValueAnimator newValueAnimator() { diff --git a/packages/SystemUI/tests/src/com/android/systemui/accessibility/WindowMagnificationControllerTest.java b/packages/SystemUI/tests/src/com/android/systemui/accessibility/WindowMagnificationControllerTest.java index 70457cf46e0db..9a3046554e0ce 100644 --- a/packages/SystemUI/tests/src/com/android/systemui/accessibility/WindowMagnificationControllerTest.java +++ b/packages/SystemUI/tests/src/com/android/systemui/accessibility/WindowMagnificationControllerTest.java @@ -89,6 +89,8 @@ public class WindowMagnificationControllerTest extends SysuiTestCase { @Mock private Handler mHandler; @Mock + private WindowMagnificationAnimationController mWindowMagnificationAnimationController; + @Mock private SfVsyncFrameCallbackProvider mSfVsyncFrameProvider; @Mock private MirrorWindowControl mMirrorWindowControl; @@ -128,7 +130,7 @@ public class WindowMagnificationControllerTest extends SysuiTestCase { mResources = getContext().getOrCreateTestableResources().getResources(); mWindowMagnificationController = new WindowMagnificationController(mContext, - mHandler, mSfVsyncFrameProvider, + mHandler, mWindowMagnificationAnimationController, mSfVsyncFrameProvider, mMirrorWindowControl, mTransaction, mWindowMagnifierCallback, mSysUiState); verify(mMirrorWindowControl).setWindowDelegate( @@ -174,7 +176,7 @@ public class WindowMagnificationControllerTest extends SysuiTestCase { mWindowManager.setWindowBounds(new Rect(0, 0, screenSize, screenSize)); //We need to initialize new one because the window size is determined when initialization. final WindowMagnificationController controller = new WindowMagnificationController(mContext, - mHandler, mSfVsyncFrameProvider, + mHandler, mWindowMagnificationAnimationController, mSfVsyncFrameProvider, mMirrorWindowControl, mTransaction, mWindowMagnifierCallback, mSysUiState); mInstrumentation.runOnMainSync(() -> { diff --git a/packages/SystemUI/tests/src/com/android/systemui/accessibility/WindowMagnificationTest.java b/packages/SystemUI/tests/src/com/android/systemui/accessibility/WindowMagnificationTest.java index fb1716aed4748..c898150d857cd 100644 --- a/packages/SystemUI/tests/src/com/android/systemui/accessibility/WindowMagnificationTest.java +++ b/packages/SystemUI/tests/src/com/android/systemui/accessibility/WindowMagnificationTest.java @@ -167,30 +167,29 @@ public class WindowMagnificationTest extends SysuiTestCase { @Test public void overviewProxyIsConnected_controllerIsAvailable_updateSysUiStateFlag() { - final WindowMagnificationAnimationController mController = mock( - WindowMagnificationAnimationController.class); - mWindowMagnification.mAnimationControllerSupplier = new FakeAnimationControllerSupplier( + final WindowMagnificationController mController = mock(WindowMagnificationController.class); + mWindowMagnification.mMagnificationControllerSupplier = new FakeControllerSupplier( mContext.getSystemService(DisplayManager.class), mController); - mWindowMagnification.mAnimationControllerSupplier.get(TEST_DISPLAY); + mWindowMagnification.mMagnificationControllerSupplier.get(TEST_DISPLAY); mOverviewProxyListener.onConnectionChanged(true); - verify(mController).updateSysUiStateFlag(); + verify(mController).updateSysUIStateFlag(); } - private static class FakeAnimationControllerSupplier extends - DisplayIdIndexSupplier { + private static class FakeControllerSupplier extends + DisplayIdIndexSupplier { - private final WindowMagnificationAnimationController mController; + private final WindowMagnificationController mController; - FakeAnimationControllerSupplier(DisplayManager displayManager, - WindowMagnificationAnimationController controller) { + FakeControllerSupplier(DisplayManager displayManager, + WindowMagnificationController controller) { super(displayManager); mController = controller; } @Override - protected WindowMagnificationAnimationController createInstance(Display display) { + protected WindowMagnificationController createInstance(Display display) { return mController; } }