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

Merge "Refactoring that make WindowMagnificationController has WindowMagnificationAnimationController"

Browse Source
This commit is contained in:
Minche Li
2021-11-18 22:52:15 +00:00
committed by Android (Google) Code Review
parent 622adb8ffe 1c4bb8dc27
commit 57176b362e
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;
}
}