Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Refactoring that make WindowMagnificationController has WindowMagnificationAnimationController

Browse Source 
It reverses the relationship between
WindowMagnificationAnimationController and WindowMagnificationController
to simplify the further changes.
1. WindowMagnificationController has
  WindowMagnificationAnimationController instance.
  WindowMagnificationController is able to know if window
  magnifier is animating or not.
  If it is animating, the setScale() action or moveMagnifier()  will
  be interrupted.
2. ControllerSupplier  supplies  WindowMagnificationController in
  WindowMagnification.class.

Bug: 206734640
Test: atest IWindowMagnificationConnectionTest,
  atest WindowMagnificationAnimationControllerTest,
  atest WindowMagnificationControllerTest,
  atest WindowMagnificationTest,
Change-Id: Ibe3471dc99d1aed506b3fd04d12131321d82a07a
This commit is contained in:
mincheli
2021-11-16 09:30:14 +08:00
parent 39c38f9b22
commit 1c4bb8dc27
7 changed files with 132 additions and 140 deletions
Download Patch File Download Diff File Expand all files Collapse all files

65
packages/SystemUI/src/com/android/systemui/accessibility/WindowMagnification.java
View File

@@ -68,15 +68,15 @@ public class WindowMagnification extends CoreStartable implements WindowMagnifie
private Configuration mLastConfiguration;
private SysUiState mSysUiState;
private static class AnimationControllerSupplier extends
DisplayIdIndexSupplier<WindowMagnificationAnimationController> {
private static class ControllerSupplier extends
DisplayIdIndexSupplier<WindowMagnificationController> {
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<WindowMagnificationAnimationController> mAnimationControllerSupplier;
DisplayIdIndexSupplier<WindowMagnificationController> 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() {

72
packages/SystemUI/src/com/android/systemui/accessibility/WindowMagnificationAnimationController.java
View File

@@ -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(

43
packages/SystemUI/src/com/android/systemui/accessibility/WindowMagnificationController.java
View File

@@ -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 <strong>less
* than or equal to 1.0f<strong>, 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)) {

22
packages/SystemUI/tests/src/com/android/systemui/accessibility/IWindowMagnificationConnectionTest.java
View File

@@ -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<WindowMagnificationAnimationController> {
private class FakeControllerSupplier extends
DisplayIdIndexSupplier<WindowMagnificationController> {
FakeAnimationControllerSupplier(DisplayManager displayManager) {
FakeControllerSupplier(DisplayManager displayManager) {
super(displayManager);
}
@Override
protected WindowMagnificationAnimationController createInstance(Display display) {
return mWindowMagnificationAnimationController;
protected WindowMagnificationController createInstance(Display display) {
return mWindowMagnificationController;
}
}
}

43
packages/SystemUI/tests/src/com/android/systemui/accessibility/WindowMagnificationAnimationControllerTest.java
View File

@@ -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() {

6
packages/SystemUI/tests/src/com/android/systemui/accessibility/WindowMagnificationControllerTest.java
View File

@@ -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(() -> {

21
packages/SystemUI/tests/src/com/android/systemui/accessibility/WindowMagnificationTest.java
View File

@@ -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<WindowMagnificationAnimationController> {
private static class FakeControllerSupplier extends
DisplayIdIndexSupplier<WindowMagnificationController> {
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;
}
}