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); + } +}