From 692a15c289260932ab53c051a180f457a99c5148 Mon Sep 17 00:00:00 2001 From: mincheli Date: Thu, 19 Aug 2021 17:46:21 +0800 Subject: [PATCH] Refactoring magnification controller for accessibility service connection It is preliminary change for AccessibilityService to control window magnifier. To make A11y service connection able to control magnification, a11y service connection has to use the magnification controller instance. However, there will be multiple magnification mode for a11y service to control. So we add magnificationProcessor class that wrap the common functions of the magnification controller to make the systemSupport interfaces less redundant. Doc: go/a11yservice_control_magnification_in_t Bug: 197205358 Test: atest AbstractAccessibilityServiceConnectionTest atest AccessibilityInputFilterTest, atest AccessibilityServiceConnectionTest, atest MagnificationProcessorTest, atest android.accessibilityservice.cts.AccessibilityMagnificationTest Change-Id: I41f0a56b5545711498eaf6383794736711db1f9c --- ...bstractAccessibilityServiceConnection.java | 71 +++----- .../AccessibilityInputFilter.java | 3 +- .../AccessibilityManagerService.java | 33 ++-- .../AccessibilityServiceConnection.java | 4 +- .../magnification/MagnificationProcessor.java | 155 +++++++++++++++++ ...actAccessibilityServiceConnectionTest.java | 92 ++-------- .../AccessibilityInputFilterTest.java | 7 +- .../AccessibilityServiceConnectionTest.java | 8 +- .../MagnificationProcessorTest.java | 162 ++++++++++++++++++ 9 files changed, 388 insertions(+), 147 deletions(-) create mode 100644 services/accessibility/java/com/android/server/accessibility/magnification/MagnificationProcessor.java create mode 100644 services/tests/servicestests/src/com/android/server/accessibility/MagnificationProcessorTest.java diff --git a/services/accessibility/java/com/android/server/accessibility/AbstractAccessibilityServiceConnection.java b/services/accessibility/java/com/android/server/accessibility/AbstractAccessibilityServiceConnection.java index b88366b5da8cc..acdbcb584a8f7 100644 --- a/services/accessibility/java/com/android/server/accessibility/AbstractAccessibilityServiceConnection.java +++ b/services/accessibility/java/com/android/server/accessibility/AbstractAccessibilityServiceConnection.java @@ -86,7 +86,7 @@ import com.android.internal.util.DumpUtils; import com.android.internal.util.function.pooled.PooledLambda; import com.android.server.LocalServices; import com.android.server.accessibility.AccessibilityWindowManager.RemoteAccessibilityConnection; -import com.android.server.accessibility.magnification.FullScreenMagnificationController; +import com.android.server.accessibility.magnification.MagnificationProcessor; import com.android.server.wm.ActivityTaskManagerInternal; import com.android.server.wm.WindowManagerInternal; @@ -223,10 +223,10 @@ abstract class AbstractAccessibilityServiceConnection extends IAccessibilityServ @Nullable FingerprintGestureDispatcher getFingerprintGestureDispatcher(); /** - * @return The magnification controller + * @return The magnification processor */ @NonNull - FullScreenMagnificationController getFullScreenMagnificationController(); + MagnificationProcessor getMagnificationProcessor(); /** * Called back to notify system that the client has changed @@ -975,7 +975,7 @@ abstract class AbstractAccessibilityServiceConnection extends IAccessibilityServ } final long identity = Binder.clearCallingIdentity(); try { - return mSystemSupport.getFullScreenMagnificationController().getScale(displayId); + return mSystemSupport.getMagnificationProcessor().getScale(displayId); } finally { Binder.restoreCallingIdentity(identity); } @@ -991,19 +991,15 @@ abstract class AbstractAccessibilityServiceConnection extends IAccessibilityServ if (!hasRightsToCurrentUserLocked()) { return region; } - FullScreenMagnificationController magnificationController = - mSystemSupport.getFullScreenMagnificationController(); - boolean registeredJustForThisCall = - registerMagnificationIfNeeded(displayId, magnificationController); + MagnificationProcessor magnificationProcessor = + mSystemSupport.getMagnificationProcessor(); final long identity = Binder.clearCallingIdentity(); try { - magnificationController.getMagnificationRegion(displayId, region); + magnificationProcessor.getMagnificationRegion(displayId, region, + mSecurityPolicy.canControlMagnification(this)); return region; } finally { Binder.restoreCallingIdentity(identity); - if (registeredJustForThisCall) { - magnificationController.unregister(displayId); - } } } } @@ -1017,18 +1013,14 @@ abstract class AbstractAccessibilityServiceConnection extends IAccessibilityServ if (!hasRightsToCurrentUserLocked()) { return 0.0f; } - FullScreenMagnificationController magnificationController = - mSystemSupport.getFullScreenMagnificationController(); - boolean registeredJustForThisCall = - registerMagnificationIfNeeded(displayId, magnificationController); + MagnificationProcessor magnificationProcessor = + mSystemSupport.getMagnificationProcessor(); final long identity = Binder.clearCallingIdentity(); try { - return magnificationController.getCenterX(displayId); + return magnificationProcessor.getCenterX(displayId, + mSecurityPolicy.canControlMagnification(this)); } finally { Binder.restoreCallingIdentity(identity); - if (registeredJustForThisCall) { - magnificationController.unregister(displayId); - } } } } @@ -1042,32 +1034,18 @@ abstract class AbstractAccessibilityServiceConnection extends IAccessibilityServ if (!hasRightsToCurrentUserLocked()) { return 0.0f; } - FullScreenMagnificationController magnificationController = - mSystemSupport.getFullScreenMagnificationController(); - boolean registeredJustForThisCall = - registerMagnificationIfNeeded(displayId, magnificationController); + MagnificationProcessor magnificationProcessor = + mSystemSupport.getMagnificationProcessor(); final long identity = Binder.clearCallingIdentity(); try { - return magnificationController.getCenterY(displayId); + return magnificationProcessor.getCenterY(displayId, + mSecurityPolicy.canControlMagnification(this)); } finally { Binder.restoreCallingIdentity(identity); - if (registeredJustForThisCall) { - magnificationController.unregister(displayId); - } } } } - private boolean registerMagnificationIfNeeded(int displayId, - FullScreenMagnificationController magnificationController) { - if (!magnificationController.isRegistered(displayId) - && mSecurityPolicy.canControlMagnification(this)) { - magnificationController.register(displayId); - return true; - } - return false; - } - @Override public boolean resetMagnification(int displayId, boolean animate) { if (svcConnTracingEnabled()) { @@ -1083,10 +1061,10 @@ abstract class AbstractAccessibilityServiceConnection extends IAccessibilityServ } final long identity = Binder.clearCallingIdentity(); try { - FullScreenMagnificationController magnificationController = - mSystemSupport.getFullScreenMagnificationController(); - return (magnificationController.reset(displayId, animate) - || !magnificationController.isMagnifying(displayId)); + MagnificationProcessor magnificationProcessor = + mSystemSupport.getMagnificationProcessor(); + return (magnificationProcessor.reset(displayId, animate) + || !magnificationProcessor.isMagnifying(displayId)); } finally { Binder.restoreCallingIdentity(identity); } @@ -1109,12 +1087,9 @@ abstract class AbstractAccessibilityServiceConnection extends IAccessibilityServ } final long identity = Binder.clearCallingIdentity(); try { - FullScreenMagnificationController magnificationController = - mSystemSupport.getFullScreenMagnificationController(); - if (!magnificationController.isRegistered(displayId)) { - magnificationController.register(displayId); - } - return magnificationController + MagnificationProcessor magnificationProcessor = + mSystemSupport.getMagnificationProcessor(); + return magnificationProcessor .setScaleAndCenter(displayId, scale, centerX, centerY, animate, mId); } finally { Binder.restoreCallingIdentity(identity); diff --git a/services/accessibility/java/com/android/server/accessibility/AccessibilityInputFilter.java b/services/accessibility/java/com/android/server/accessibility/AccessibilityInputFilter.java index 7d2b71f7852b9..10cfd04ebca6f 100644 --- a/services/accessibility/java/com/android/server/accessibility/AccessibilityInputFilter.java +++ b/services/accessibility/java/com/android/server/accessibility/AccessibilityInputFilter.java @@ -608,7 +608,8 @@ class AccessibilityInputFilter extends InputFilter implements EventStreamTransfo final Context uiContext = displayContext.createWindowContext( TYPE_MAGNIFICATION_OVERLAY, null /* options */); magnificationGestureHandler = new FullScreenMagnificationGestureHandler(uiContext, - mAms.getFullScreenMagnificationController(), mAms.getTraceManager(), + mAms.getMagnificationController().getFullScreenMagnificationController(), + mAms.getTraceManager(), mAms.getMagnificationController(), detectControlGestures, triggerable, new WindowMagnificationPromptController(displayContext, mUserId), displayId); } diff --git a/services/accessibility/java/com/android/server/accessibility/AccessibilityManagerService.java b/services/accessibility/java/com/android/server/accessibility/AccessibilityManagerService.java index a9cd0ed2d5292..aff7eb2274e52 100644 --- a/services/accessibility/java/com/android/server/accessibility/AccessibilityManagerService.java +++ b/services/accessibility/java/com/android/server/accessibility/AccessibilityManagerService.java @@ -126,8 +126,8 @@ import com.android.internal.util.DumpUtils; import com.android.internal.util.IntPair; import com.android.server.LocalServices; import com.android.server.SystemService; -import com.android.server.accessibility.magnification.FullScreenMagnificationController; import com.android.server.accessibility.magnification.MagnificationController; +import com.android.server.accessibility.magnification.MagnificationProcessor; import com.android.server.accessibility.magnification.WindowMagnificationManager; import com.android.server.pm.UserManagerInternal; import com.android.server.wm.ActivityTaskManagerInternal; @@ -219,6 +219,9 @@ public class AccessibilityManagerService extends IAccessibilityManager.Stub private final ActivityTaskManagerInternal mActivityTaskManagerService; + private final MagnificationController mMagnificationController; + private final MagnificationProcessor mMagnificationProcessor; + private final MainHandler mMainHandler; // Lazily initialized - access through getSystemActionPerfomer() @@ -261,7 +264,6 @@ public class AccessibilityManagerService extends IAccessibilityManager.Stub private Point mTempPoint = new Point(); private boolean mIsAccessibilityButtonShown; - private MagnificationController mMagnificationController; private AccessibilityUserState getCurrentUserStateLocked() { return getUserStateLocked(mCurrentUserId); @@ -308,6 +310,7 @@ public class AccessibilityManagerService extends IAccessibilityManager.Stub mA11yWindowManager = a11yWindowManager; mA11yDisplayListener = a11yDisplayListener; mMagnificationController = magnificationController; + mMagnificationProcessor = new MagnificationProcessor(mMagnificationController); init(); } @@ -336,6 +339,7 @@ public class AccessibilityManagerService extends IAccessibilityManager.Stub mWindowManagerService, this, mSecurityPolicy, this, mTraceManager); mA11yDisplayListener = new AccessibilityDisplayListener(mContext, mMainHandler); mMagnificationController = new MagnificationController(this, mLock, mContext); + mMagnificationProcessor = new MagnificationProcessor(mMagnificationController); init(); } @@ -2535,7 +2539,7 @@ public class AccessibilityManagerService extends IAccessibilityManager.Stub if (mUiAutomationManager.suppressingAccessibilityServicesLocked() && mMagnificationController.isFullScreenMagnificationControllerInitialized()) { - getFullScreenMagnificationController().unregisterAll(); + getMagnificationController().getFullScreenMagnificationController().unregisterAll(); return; } @@ -2547,7 +2551,8 @@ public class AccessibilityManagerService extends IAccessibilityManager.Stub || userState.isShortcutMagnificationEnabledLocked()) { for (int i = 0; i < displays.size(); i++) { final Display display = displays.get(i); - getFullScreenMagnificationController().register(display.getDisplayId()); + getMagnificationController().getFullScreenMagnificationController().register( + display.getDisplayId()); } return; } @@ -2557,9 +2562,11 @@ public class AccessibilityManagerService extends IAccessibilityManager.Stub final Display display = displays.get(i); final int displayId = display.getDisplayId(); if (userHasListeningMagnificationServicesLocked(userState, displayId)) { - getFullScreenMagnificationController().register(displayId); + getMagnificationController().getFullScreenMagnificationController().register( + displayId); } else if (mMagnificationController.isFullScreenMagnificationControllerInitialized()) { - getFullScreenMagnificationController().unregister(displayId); + getMagnificationController().getFullScreenMagnificationController().unregister( + displayId); } } } @@ -2922,7 +2929,9 @@ public class AccessibilityManagerService extends IAccessibilityManager.Stub } // In case user assigned magnification to the given shortcut. if (targetName.equals(MAGNIFICATION_CONTROLLER_NAME)) { - final boolean enabled = !getFullScreenMagnificationController().isMagnifying(displayId); + final boolean enabled = + !getMagnificationController().getFullScreenMagnificationController() + .isMagnifying(displayId); logAccessibilityShortcutActivated(mContext, MAGNIFICATION_COMPONENT_NAME, shortcutType, enabled); sendAccessibilityButtonToInputFilter(displayId); @@ -3259,9 +3268,7 @@ public class AccessibilityManagerService extends IAccessibilityManager.Stub * @return MagnificationController */ MagnificationController getMagnificationController() { - synchronized (mLock) { - return mMagnificationController; - } + return mMagnificationController; } @Override @@ -3378,10 +3385,8 @@ public class AccessibilityManagerService extends IAccessibilityManager.Stub } @Override - public FullScreenMagnificationController getFullScreenMagnificationController() { - synchronized (mLock) { - return mMagnificationController.getFullScreenMagnificationController(); - } + public MagnificationProcessor getMagnificationProcessor() { + return mMagnificationProcessor; } @Override diff --git a/services/accessibility/java/com/android/server/accessibility/AccessibilityServiceConnection.java b/services/accessibility/java/com/android/server/accessibility/AccessibilityServiceConnection.java index 467cab5fec04d..4bf48a25477fc 100644 --- a/services/accessibility/java/com/android/server/accessibility/AccessibilityServiceConnection.java +++ b/services/accessibility/java/com/android/server/accessibility/AccessibilityServiceConnection.java @@ -123,7 +123,7 @@ class AccessibilityServiceConnection extends AbstractAccessibilityServiceConnect AccessibilityUserState userState = mUserStateWeakReference.get(); if (userState == null) return; userState.removeServiceLocked(this); - mSystemSupport.getFullScreenMagnificationController().resetAllIfNeeded(mId); + mSystemSupport.getMagnificationProcessor().resetAllIfNeeded(mId); mActivityTaskManagerService.setAllowAppSwitches(mComponentName.flattenToString(), -1, userState.mUserId); resetLocked(); @@ -334,7 +334,7 @@ class AccessibilityServiceConnection extends AbstractAccessibilityServiceConnect userState.serviceDisconnectedLocked(this); } resetLocked(); - mSystemSupport.getFullScreenMagnificationController().resetAllIfNeeded(mId); + mSystemSupport.getMagnificationProcessor().resetAllIfNeeded(mId); mSystemSupport.onClientChangeLocked(false); } } diff --git a/services/accessibility/java/com/android/server/accessibility/magnification/MagnificationProcessor.java b/services/accessibility/java/com/android/server/accessibility/magnification/MagnificationProcessor.java new file mode 100644 index 0000000000000..efc6d515fdb83 --- /dev/null +++ b/services/accessibility/java/com/android/server/accessibility/magnification/MagnificationProcessor.java @@ -0,0 +1,155 @@ +/* + * Copyright (C) 2021 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.server.accessibility.magnification; + +import android.annotation.NonNull; +import android.graphics.Region; + +/** + * Processor class for AccessibilityService connection to control magnification on the specified + * display. This wraps the function of magnification controller. + * + * @see MagnificationController + * @see FullScreenMagnificationController + */ +public class MagnificationProcessor { + + private final MagnificationController mController; + + public MagnificationProcessor(MagnificationController controller) { + mController = controller; + } + + /** + * {@link FullScreenMagnificationController#getScale(int)} + */ + public float getScale(int displayId) { + return mController.getFullScreenMagnificationController().getScale(displayId); + } + + /** + * {@link FullScreenMagnificationController#getCenterX(int)} + */ + public float getCenterX(int displayId, boolean canControlMagnification) { + boolean registeredJustForThisCall = registerMagnificationIfNeeded(displayId, + canControlMagnification); + try { + return mController.getFullScreenMagnificationController().getCenterX(displayId); + } finally { + if (registeredJustForThisCall) { + unregister(displayId); + } + } + } + + /** + * {@link FullScreenMagnificationController#getCenterY(int)} + */ + public float getCenterY(int displayId, boolean canControlMagnification) { + boolean registeredJustForThisCall = registerMagnificationIfNeeded(displayId, + canControlMagnification); + try { + return mController.getFullScreenMagnificationController().getCenterY(displayId); + } finally { + if (registeredJustForThisCall) { + unregister(displayId); + } + } + } + + /** + * {@link FullScreenMagnificationController#getMagnificationRegion(int, Region)} + */ + public Region getMagnificationRegion(int displayId, @NonNull Region outRegion, + boolean canControlMagnification) { + boolean registeredJustForThisCall = registerMagnificationIfNeeded(displayId, + canControlMagnification); + try { + mController.getFullScreenMagnificationController().getMagnificationRegion(displayId, + outRegion); + return outRegion; + } finally { + if (registeredJustForThisCall) { + unregister(displayId); + } + } + } + + /** + * {@link FullScreenMagnificationController#setScaleAndCenter(int, float, float, float, boolean, + * int)} + */ + public boolean setScaleAndCenter(int displayId, float scale, float centerX, float centerY, + boolean animate, int id) { + if (!isRegistered(displayId)) { + register(displayId); + } + return mController.getFullScreenMagnificationController().setScaleAndCenter(displayId, + scale, + centerX, centerY, animate, id); + } + + /** + * {@link FullScreenMagnificationController#reset(int, boolean)} + */ + public boolean reset(int displayId, boolean animate) { + return mController.getFullScreenMagnificationController().reset(displayId, animate); + } + + /** + * {@link FullScreenMagnificationController#resetIfNeeded(int, boolean)} + */ + public void resetAllIfNeeded(int connectionId) { + mController.getFullScreenMagnificationController().resetAllIfNeeded(connectionId); + } + + /** + * {@link FullScreenMagnificationController#register(int)} + */ + public void register(int displayId) { + mController.getFullScreenMagnificationController().register(displayId); + } + + /** + * {@link FullScreenMagnificationController#unregister(int)} (int)} + */ + public void unregister(int displayId) { + mController.getFullScreenMagnificationController().unregister(displayId); + } + + /** + * {@link FullScreenMagnificationController#isMagnifying(int)} + */ + public boolean isMagnifying(int displayId) { + return mController.getFullScreenMagnificationController().isMagnifying(displayId); + } + + /** + * {@link FullScreenMagnificationController#isRegistered(int)} + */ + public boolean isRegistered(int displayId) { + return mController.getFullScreenMagnificationController().isRegistered(displayId); + } + + private boolean registerMagnificationIfNeeded(int displayId, boolean canControlMagnification) { + if (!isRegistered(displayId) && canControlMagnification) { + register(displayId); + return true; + } + return false; + } +} diff --git a/services/tests/servicestests/src/com/android/server/accessibility/AbstractAccessibilityServiceConnectionTest.java b/services/tests/servicestests/src/com/android/server/accessibility/AbstractAccessibilityServiceConnectionTest.java index e612d121b0930..086e3c0901a82 100644 --- a/services/tests/servicestests/src/com/android/server/accessibility/AbstractAccessibilityServiceConnectionTest.java +++ b/services/tests/servicestests/src/com/android/server/accessibility/AbstractAccessibilityServiceConnectionTest.java @@ -53,6 +53,7 @@ import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertThat; import static org.junit.Assert.assertTrue; import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.anyBoolean; import static org.mockito.ArgumentMatchers.anyInt; import static org.mockito.ArgumentMatchers.anyLong; import static org.mockito.ArgumentMatchers.eq; @@ -92,7 +93,7 @@ import android.view.accessibility.IAccessibilityInteractionConnection; import android.view.accessibility.IAccessibilityInteractionConnectionCallback; import com.android.server.accessibility.AccessibilityWindowManager.RemoteAccessibilityConnection; -import com.android.server.accessibility.magnification.FullScreenMagnificationController; +import com.android.server.accessibility.magnification.MagnificationProcessor; import com.android.server.accessibility.test.MessageCapturingHandler; import com.android.server.wm.WindowManagerInternal; @@ -170,7 +171,7 @@ public class AbstractAccessibilityServiceConnectionTest { @Mock private IAccessibilityInteractionConnection mMockIA11yInteractionConnection; @Mock private IAccessibilityInteractionConnectionCallback mMockCallback; @Mock private FingerprintGestureDispatcher mMockFingerprintGestureDispatcher; - @Mock private FullScreenMagnificationController mMockFullScreenMagnificationController; + @Mock private MagnificationProcessor mMockMagnificationProcessor; @Mock private RemoteCallback.OnResultListener mMockListener; @Before @@ -181,8 +182,8 @@ public class AbstractAccessibilityServiceConnectionTest { when(mMockSystemSupport.getKeyEventDispatcher()).thenReturn(mMockKeyEventDispatcher); when(mMockSystemSupport.getFingerprintGestureDispatcher()) .thenReturn(mMockFingerprintGestureDispatcher); - when(mMockSystemSupport.getFullScreenMagnificationController()) - .thenReturn(mMockFullScreenMagnificationController); + when(mMockSystemSupport.getMagnificationProcessor()) + .thenReturn(mMockMagnificationProcessor); PowerManager powerManager = new PowerManager(mMockContext, mMockIPowerManager, mMockIThermalService, mHandler); @@ -558,7 +559,7 @@ public class AbstractAccessibilityServiceConnectionTest { public void getMagnificationScale() { final int displayId = 1; final float scale = 2.0f; - when(mMockFullScreenMagnificationController.getScale(displayId)).thenReturn(scale); + when(mMockMagnificationProcessor.getScale(displayId)).thenReturn(scale); final float result = mServiceConnection.getMagnificationScale(displayId); assertThat(result, is(scale)); @@ -568,30 +569,13 @@ public class AbstractAccessibilityServiceConnectionTest { public void getMagnificationScale_serviceNotBelongCurrentUser_returnNoScale() { final int displayId = 1; final float scale = 2.0f; - when(mMockFullScreenMagnificationController.getScale(displayId)).thenReturn(scale); + when(mMockMagnificationProcessor.getScale(displayId)).thenReturn(scale); when(mMockSystemSupport.getCurrentUserIdLocked()).thenReturn(USER_ID2); final float result = mServiceConnection.getMagnificationScale(displayId); assertThat(result, is(1.0f)); } - @Test - public void getMagnificationRegion_notRegistered_shouldRegisterThenUnregister() { - final int displayId = 1; - final Region region = new Region(10, 20, 100, 200); - doAnswer((invocation) -> { - ((Region) invocation.getArguments()[1]).set(region); - return null; - }).when(mMockFullScreenMagnificationController).getMagnificationRegion(eq(displayId), - any()); - when(mMockFullScreenMagnificationController.isRegistered(displayId)).thenReturn(false); - - final Region result = mServiceConnection.getMagnificationRegion(displayId); - assertThat(result, is(region)); - verify(mMockFullScreenMagnificationController).register(displayId); - verify(mMockFullScreenMagnificationController).unregister(displayId); - } - @Test public void getMagnificationRegion_serviceNotBelongCurrentUser_returnEmptyRegion() { final int displayId = 1; @@ -599,56 +583,32 @@ public class AbstractAccessibilityServiceConnectionTest { doAnswer((invocation) -> { ((Region) invocation.getArguments()[1]).set(region); return null; - }).when(mMockFullScreenMagnificationController).getMagnificationRegion(eq(displayId), - any()); + }).when(mMockMagnificationProcessor).getMagnificationRegion(eq(displayId), + any(), anyBoolean()); when(mMockSystemSupport.getCurrentUserIdLocked()).thenReturn(USER_ID2); final Region result = mServiceConnection.getMagnificationRegion(displayId); assertThat(result.isEmpty(), is(true)); } - @Test - public void getMagnificationCenterX_notRegistered_shouldRegisterThenUnregister() { - final int displayId = 1; - final float centerX = 480.0f; - when(mMockFullScreenMagnificationController.getCenterX(displayId)).thenReturn(centerX); - when(mMockFullScreenMagnificationController.isRegistered(displayId)).thenReturn(false); - - final float result = mServiceConnection.getMagnificationCenterX(displayId); - assertThat(result, is(centerX)); - verify(mMockFullScreenMagnificationController).register(displayId); - verify(mMockFullScreenMagnificationController).unregister(displayId); - } - @Test public void getMagnificationCenterX_serviceNotBelongCurrentUser_returnZero() { final int displayId = 1; final float centerX = 480.0f; - when(mMockFullScreenMagnificationController.getCenterX(displayId)).thenReturn(centerX); + when(mMockMagnificationProcessor.getCenterX(displayId, /* canControlMagnification= */ + true)).thenReturn(centerX); when(mMockSystemSupport.getCurrentUserIdLocked()).thenReturn(USER_ID2); final float result = mServiceConnection.getMagnificationCenterX(displayId); assertThat(result, is(0.0f)); } - @Test - public void getMagnificationCenterY_notRegistered_shouldRegisterThenUnregister() { - final int displayId = 1; - final float centerY = 640.0f; - when(mMockFullScreenMagnificationController.getCenterY(displayId)).thenReturn(centerY); - when(mMockFullScreenMagnificationController.isRegistered(displayId)).thenReturn(false); - - final float result = mServiceConnection.getMagnificationCenterY(displayId); - assertThat(result, is(centerY)); - verify(mMockFullScreenMagnificationController).register(displayId); - verify(mMockFullScreenMagnificationController).unregister(displayId); - } - @Test public void getMagnificationCenterY_serviceNotBelongCurrentUser_returnZero() { final int displayId = 1; final float centerY = 640.0f; - when(mMockFullScreenMagnificationController.getCenterY(displayId)).thenReturn(centerY); + when(mMockMagnificationProcessor.getCenterY(displayId, /* canControlMagnification= */ + true)).thenReturn(centerY); when(mMockSystemSupport.getCurrentUserIdLocked()).thenReturn(USER_ID2); final float result = mServiceConnection.getMagnificationCenterY(displayId); @@ -658,7 +618,7 @@ public class AbstractAccessibilityServiceConnectionTest { @Test public void resetMagnification() { final int displayId = 1; - when(mMockFullScreenMagnificationController.reset(displayId, true)).thenReturn(true); + when(mMockMagnificationProcessor.reset(displayId, true)).thenReturn(true); final boolean result = mServiceConnection.resetMagnification(displayId, true); assertThat(result, is(true)); @@ -667,7 +627,7 @@ public class AbstractAccessibilityServiceConnectionTest { @Test public void resetMagnification_cantControlMagnification_returnFalse() { final int displayId = 1; - when(mMockFullScreenMagnificationController.reset(displayId, true)).thenReturn(true); + when(mMockMagnificationProcessor.reset(displayId, true)).thenReturn(true); when(mMockSecurityPolicy.canControlMagnification(mServiceConnection)).thenReturn(false); final boolean result = mServiceConnection.resetMagnification(displayId, true); @@ -677,36 +637,20 @@ public class AbstractAccessibilityServiceConnectionTest { @Test public void resetMagnification_serviceNotBelongCurrentUser_returnFalse() { final int displayId = 1; - when(mMockFullScreenMagnificationController.reset(displayId, true)).thenReturn(true); + when(mMockMagnificationProcessor.reset(displayId, true)).thenReturn(true); when(mMockSystemSupport.getCurrentUserIdLocked()).thenReturn(USER_ID2); final boolean result = mServiceConnection.resetMagnification(displayId, true); assertThat(result, is(false)); } - @Test - public void setMagnificationScaleAndCenter_notRegistered_shouldRegister() { - final int displayId = 1; - final float scale = 1.8f; - final float centerX = 50.5f; - final float centerY = 100.5f; - when(mMockFullScreenMagnificationController.setScaleAndCenter(displayId, - scale, centerX, centerY, true, SERVICE_ID)).thenReturn(true); - when(mMockFullScreenMagnificationController.isRegistered(displayId)).thenReturn(false); - - final boolean result = mServiceConnection.setMagnificationScaleAndCenter( - displayId, scale, centerX, centerY, true); - assertThat(result, is(true)); - verify(mMockFullScreenMagnificationController).register(displayId); - } - @Test public void setMagnificationScaleAndCenter_cantControlMagnification_returnFalse() { final int displayId = 1; final float scale = 1.8f; final float centerX = 50.5f; final float centerY = 100.5f; - when(mMockFullScreenMagnificationController.setScaleAndCenter(displayId, + when(mMockMagnificationProcessor.setScaleAndCenter(displayId, scale, centerX, centerY, true, SERVICE_ID)).thenReturn(true); when(mMockSecurityPolicy.canControlMagnification(mServiceConnection)).thenReturn(false); @@ -721,7 +665,7 @@ public class AbstractAccessibilityServiceConnectionTest { final float scale = 1.8f; final float centerX = 50.5f; final float centerY = 100.5f; - when(mMockFullScreenMagnificationController.setScaleAndCenter(displayId, + when(mMockMagnificationProcessor.setScaleAndCenter(displayId, scale, centerX, centerY, true, SERVICE_ID)).thenReturn(true); when(mMockSystemSupport.getCurrentUserIdLocked()).thenReturn(USER_ID2); diff --git a/services/tests/servicestests/src/com/android/server/accessibility/AccessibilityInputFilterTest.java b/services/tests/servicestests/src/com/android/server/accessibility/AccessibilityInputFilterTest.java index 554f0a4265be0..464fee2bfc114 100644 --- a/services/tests/servicestests/src/com/android/server/accessibility/AccessibilityInputFilterTest.java +++ b/services/tests/servicestests/src/com/android/server/accessibility/AccessibilityInputFilterTest.java @@ -53,9 +53,9 @@ import androidx.test.runner.AndroidJUnit4; import com.android.server.LocalServices; import com.android.server.accessibility.gestures.TouchExplorer; -import com.android.server.accessibility.magnification.FullScreenMagnificationController; import com.android.server.accessibility.magnification.FullScreenMagnificationGestureHandler; import com.android.server.accessibility.magnification.MagnificationGestureHandler; +import com.android.server.accessibility.magnification.MagnificationProcessor; import com.android.server.accessibility.magnification.WindowMagnificationGestureHandler; import com.android.server.wm.WindowManagerInternal; @@ -96,7 +96,7 @@ public class AccessibilityInputFilterTest { @Mock private WindowManagerInternal.AccessibilityControllerInternal mMockA11yController; @Mock private WindowManagerInternal mMockWindowManagerService; - @Mock private FullScreenMagnificationController mMockFullScreenMagnificationController; + @Mock private MagnificationProcessor mMockMagnificationProcessor; private AccessibilityManagerService mAms; private AccessibilityInputFilter mA11yInputFilter; private EventCaptor mCaptor1; @@ -152,8 +152,7 @@ public class AccessibilityInputFilterTest { mA11yInputFilter.onInstalled(); doReturn(mDisplayList).when(mAms).getValidDisplayList(); - doReturn(mMockFullScreenMagnificationController).when(mAms) - .getFullScreenMagnificationController(); + doReturn(mMockMagnificationProcessor).when(mAms).getMagnificationProcessor(); } @After diff --git a/services/tests/servicestests/src/com/android/server/accessibility/AccessibilityServiceConnectionTest.java b/services/tests/servicestests/src/com/android/server/accessibility/AccessibilityServiceConnectionTest.java index 432a500a50417..e93e5444870e9 100644 --- a/services/tests/servicestests/src/com/android/server/accessibility/AccessibilityServiceConnectionTest.java +++ b/services/tests/servicestests/src/com/android/server/accessibility/AccessibilityServiceConnectionTest.java @@ -45,7 +45,7 @@ import android.os.UserHandle; import android.testing.DexmakerShareClassLoaderRule; import android.view.Display; -import com.android.server.accessibility.magnification.FullScreenMagnificationController; +import com.android.server.accessibility.magnification.MagnificationProcessor; import com.android.server.accessibility.test.MessageCapturingHandler; import com.android.server.wm.ActivityTaskManagerInternal; import com.android.server.wm.WindowManagerInternal; @@ -91,7 +91,7 @@ public class AccessibilityServiceConnectionTest { @Mock SystemActionPerformer mMockSystemActionPerformer; @Mock KeyEventDispatcher mMockKeyEventDispatcher; @Mock - FullScreenMagnificationController mMockFullScreenMagnificationController; + MagnificationProcessor mMockMagnificationProcessor; @Mock IBinder mMockIBinder; @Mock IAccessibilityServiceClient mMockServiceClient; @Mock MotionEventInjector mMockMotionEventInjector; @@ -102,8 +102,8 @@ public class AccessibilityServiceConnectionTest { public void setup() { MockitoAnnotations.initMocks(this); when(mMockSystemSupport.getKeyEventDispatcher()).thenReturn(mMockKeyEventDispatcher); - when(mMockSystemSupport.getFullScreenMagnificationController()) - .thenReturn(mMockFullScreenMagnificationController); + when(mMockSystemSupport.getMagnificationProcessor()) + .thenReturn(mMockMagnificationProcessor); when(mMockSystemSupport.getMotionEventInjectorForDisplayLocked( Display.DEFAULT_DISPLAY)).thenReturn(mMockMotionEventInjector); diff --git a/services/tests/servicestests/src/com/android/server/accessibility/MagnificationProcessorTest.java b/services/tests/servicestests/src/com/android/server/accessibility/MagnificationProcessorTest.java new file mode 100644 index 0000000000000..c412b94035610 --- /dev/null +++ b/services/tests/servicestests/src/com/android/server/accessibility/MagnificationProcessorTest.java @@ -0,0 +1,162 @@ +/* + * Copyright (C) 2021 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.server.accessibility; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.doAnswer; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import android.graphics.Region; + +import com.android.server.accessibility.magnification.FullScreenMagnificationController; +import com.android.server.accessibility.magnification.MagnificationController; +import com.android.server.accessibility.magnification.MagnificationProcessor; + +import org.junit.Before; +import org.junit.Test; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; + + +/** + * Tests for the {@link MagnificationProcessor} + */ +public class MagnificationProcessorTest { + + private static final int TEST_DISPLAY = 0; + + private MagnificationProcessor mMagnificationProcessor; + @Mock + private MagnificationController mMockMagnificationController; + @Mock + private FullScreenMagnificationController mMockFullScreenMagnificationController; + + @Before + public void setup() { + MockitoAnnotations.initMocks(this); + + when(mMockMagnificationController.getFullScreenMagnificationController()).thenReturn( + mMockFullScreenMagnificationController); + mMagnificationProcessor = new MagnificationProcessor(mMockMagnificationController); + } + + @Test + public void getScale() { + final float result = 2; + when(mMockFullScreenMagnificationController.getScale(TEST_DISPLAY)).thenReturn(result); + + float scale = mMagnificationProcessor.getScale(TEST_DISPLAY); + + assertEquals(scale, result, 0); + } + + @Test + public void getCenterX_canControlMagnification_returnCenterX() { + final float result = 200; + when(mMockFullScreenMagnificationController.getCenterX(TEST_DISPLAY)).thenReturn(result); + + float centerX = mMagnificationProcessor.getCenterX( + TEST_DISPLAY, /* canControlMagnification= */true); + + assertEquals(centerX, result, 0); + } + + @Test + public void getCenterY_canControlMagnification_returnCenterY() { + final float result = 300; + when(mMockFullScreenMagnificationController.getCenterY(TEST_DISPLAY)).thenReturn(result); + + float centerY = mMagnificationProcessor.getCenterY( + TEST_DISPLAY, /* canControlMagnification= */false); + + assertEquals(centerY, result, 0); + } + + @Test + public void getMagnificationRegion_canControlMagnification_returnRegion() { + final Region region = new Region(10, 20, 100, 200); + mMagnificationProcessor.getMagnificationRegion(TEST_DISPLAY, + region, /* canControlMagnification= */true); + + verify(mMockFullScreenMagnificationController).getMagnificationRegion(eq(TEST_DISPLAY), + eq(region)); + } + + @Test + public void getMagnificationRegion_notRegistered_shouldRegisterThenUnregister() { + final Region region = new Region(10, 20, 100, 200); + doAnswer((invocation) -> { + ((Region) invocation.getArguments()[1]).set(region); + return null; + }).when(mMockFullScreenMagnificationController).getMagnificationRegion(eq(TEST_DISPLAY), + any()); + when(mMockFullScreenMagnificationController.isRegistered(TEST_DISPLAY)).thenReturn(false); + + final Region result = new Region(); + mMagnificationProcessor.getMagnificationRegion(TEST_DISPLAY, + result, /* canControlMagnification= */true); + assertEquals(region, result); + verify(mMockFullScreenMagnificationController).register(TEST_DISPLAY); + verify(mMockFullScreenMagnificationController).unregister(TEST_DISPLAY); + } + + @Test + public void getMagnificationCenterX_notRegistered_shouldRegisterThenUnregister() { + final float centerX = 480.0f; + when(mMockFullScreenMagnificationController.getCenterX(TEST_DISPLAY)).thenReturn(centerX); + when(mMockFullScreenMagnificationController.isRegistered(TEST_DISPLAY)).thenReturn(false); + + final float result = mMagnificationProcessor.getCenterX( + TEST_DISPLAY, /* canControlMagnification= */ true); + assertEquals(centerX, result, 0); + verify(mMockFullScreenMagnificationController).register(TEST_DISPLAY); + verify(mMockFullScreenMagnificationController).unregister(TEST_DISPLAY); + } + + @Test + public void getMagnificationCenterY_notRegistered_shouldRegisterThenUnregister() { + final float centerY = 640.0f; + when(mMockFullScreenMagnificationController.getCenterY(TEST_DISPLAY)).thenReturn(centerY); + when(mMockFullScreenMagnificationController.isRegistered(TEST_DISPLAY)).thenReturn(false); + + final float result = mMagnificationProcessor.getCenterY( + TEST_DISPLAY, /* canControlMagnification= */ true); + assertEquals(centerY, result, 0); + verify(mMockFullScreenMagnificationController).register(TEST_DISPLAY); + verify(mMockFullScreenMagnificationController).unregister(TEST_DISPLAY); + } + + @Test + public void setMagnificationScaleAndCenter_notRegistered_shouldRegister() { + final int serviceId = 42; + final float scale = 1.8f; + final float centerX = 50.5f; + final float centerY = 100.5f; + when(mMockFullScreenMagnificationController.setScaleAndCenter(TEST_DISPLAY, + scale, centerX, centerY, true, serviceId)).thenReturn(true); + when(mMockFullScreenMagnificationController.isRegistered(TEST_DISPLAY)).thenReturn(false); + + final boolean result = mMagnificationProcessor.setScaleAndCenter( + TEST_DISPLAY, scale, centerX, centerY, true, serviceId); + assertTrue(result); + verify(mMockFullScreenMagnificationController).register(TEST_DISPLAY); + } +}