diff options
11 files changed, 731 insertions, 146 deletions
diff --git a/packages/SystemUI/src/com/android/systemui/accessibility/MagnificationSettingsController.java b/packages/SystemUI/src/com/android/systemui/accessibility/MagnificationSettingsController.java new file mode 100644 index 000000000000..57cf7b921319 --- /dev/null +++ b/packages/SystemUI/src/com/android/systemui/accessibility/MagnificationSettingsController.java @@ -0,0 +1,210 @@ +/* + * Copyright (C) 2023 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.systemui.accessibility; + +import static com.android.systemui.accessibility.WindowMagnificationSettings.MagnificationSize; + +import android.annotation.NonNull; +import android.annotation.UiContext; +import android.content.ComponentCallbacks; +import android.content.Context; +import android.content.res.Configuration; +import android.util.Range; + +import com.android.internal.annotations.VisibleForTesting; +import com.android.internal.graphics.SfVsyncFrameCallbackProvider; +import com.android.systemui.util.settings.SecureSettings; + +/** + * A class to control {@link WindowMagnificationSettings} and receive settings panel callbacks by + * {@link WindowMagnificationSettingsCallback}. + * The settings panel callbacks will be delegated through + * {@link MagnificationSettingsController.Callback} to {@link WindowMagnification}. + */ + +public class MagnificationSettingsController implements ComponentCallbacks { + + // It should be consistent with the value defined in WindowMagnificationGestureHandler. + private static final Range<Float> A11Y_ACTION_SCALE_RANGE = new Range<>(1.0f, 8.0f); + + private final Context mContext; + + private final int mDisplayId; + + @NonNull + private final Callback mSettingsControllerCallback; + + // Window Magnification Setting view + private WindowMagnificationSettings mWindowMagnificationSettings; + + private final Configuration mConfiguration; + + MagnificationSettingsController( + @UiContext Context context, + SfVsyncFrameCallbackProvider sfVsyncFrameProvider, + @NonNull Callback settingsControllerCallback, + SecureSettings secureSettings) { + this(context, sfVsyncFrameProvider, settingsControllerCallback, secureSettings, null); + } + + @VisibleForTesting + MagnificationSettingsController( + @UiContext Context context, + SfVsyncFrameCallbackProvider sfVsyncFrameProvider, + @NonNull Callback settingsControllerCallback, + SecureSettings secureSettings, + WindowMagnificationSettings windowMagnificationSettings) { + mContext = context; + mDisplayId = mContext.getDisplayId(); + mConfiguration = new Configuration(context.getResources().getConfiguration()); + mSettingsControllerCallback = settingsControllerCallback; + if (windowMagnificationSettings != null) { + mWindowMagnificationSettings = windowMagnificationSettings; + } else { + mWindowMagnificationSettings = new WindowMagnificationSettings(context, + mWindowMagnificationSettingsCallback, + sfVsyncFrameProvider, secureSettings); + } + } + + void showMagnificationSettings() { + if (!mWindowMagnificationSettings.isSettingPanelShowing()) { + onConfigurationChanged(mContext.getResources().getConfiguration()); + mContext.registerComponentCallbacks(this); + } + mWindowMagnificationSettings.showSettingPanel(); + } + + void closeMagnificationSettings() { + mContext.unregisterComponentCallbacks(this); + mWindowMagnificationSettings.hideSettingPanel(); + } + + boolean isMagnificationSettingsShowing() { + return mWindowMagnificationSettings.isSettingPanelShowing(); + } + + @Override + public void onConfigurationChanged(@NonNull Configuration newConfig) { + final int configDiff = newConfig.diff(mConfiguration); + mConfiguration.setTo(newConfig); + onConfigurationChanged(configDiff); + } + + @VisibleForTesting + void onConfigurationChanged(int configDiff) { + mWindowMagnificationSettings.onConfigurationChanged(configDiff); + } + + @Override + public void onLowMemory() { + + } + + interface Callback { + + /** + * Called when change magnification size. + * + * @param displayId The logical display id. + * @param index Magnification size index. + * 0 : MagnificationSize.NONE, + * 1 : MagnificationSize.SMALL, + * 2 : MagnificationSize.MEDIUM, + * 3 : MagnificationSize.LARGE, + * 4 : MagnificationSize.FULLSCREEN + */ + void onSetMagnifierSize(int displayId, @MagnificationSize int index); + + /** + * Called when set allow diagonal scrolling. + * + * @param displayId The logical display id. + * @param enable Allow diagonal scrolling enable value. + */ + void onSetDiagonalScrolling(int displayId, boolean enable); + + /** + * Called when change magnification size on free mode. + * + * @param displayId The logical display id. + * @param enable Free mode enable value. + */ + void onEditMagnifierSizeMode(int displayId, boolean enable); + + /** + * Called when set magnification scale. + * + * @param displayId The logical display id. + * @param scale Magnification scale value. + */ + void onMagnifierScale(int displayId, float scale); + + /** + * Called when magnification mode changed. + * + * @param displayId The logical display id. + * @param newMode Magnification mode + * 1 : ACCESSIBILITY_MAGNIFICATION_MODE_FULLSCREEN, + * 2 : ACCESSIBILITY_MAGNIFICATION_MODE_WINDOW + */ + void onModeSwitch(int displayId, int newMode); + + /** + * Called when the visibility of the magnification settings panel changed. + * + * @param displayId The logical display id. + * @param shown The visibility of the magnification settings panel. + */ + void onSettingsPanelVisibilityChanged(int displayId, boolean shown); + } + + @VisibleForTesting + final WindowMagnificationSettingsCallback mWindowMagnificationSettingsCallback = + new WindowMagnificationSettingsCallback() { + @Override + public void onSetDiagonalScrolling(boolean enable) { + mSettingsControllerCallback.onSetDiagonalScrolling(mDisplayId, enable); + } + + @Override + public void onModeSwitch(int newMode) { + mSettingsControllerCallback.onModeSwitch(mDisplayId, newMode); + } + + @Override + public void onSettingsPanelVisibilityChanged(boolean shown) { + mSettingsControllerCallback.onSettingsPanelVisibilityChanged(mDisplayId, shown); + } + + @Override + public void onSetMagnifierSize(@MagnificationSize int index) { + mSettingsControllerCallback.onSetMagnifierSize(mDisplayId, index); + } + + @Override + public void onEditMagnifierSizeMode(boolean enable) { + mSettingsControllerCallback.onEditMagnifierSizeMode(mDisplayId, enable); + } + + @Override + public void onMagnifierScale(float scale) { + mSettingsControllerCallback.onMagnifierScale(mDisplayId, + A11Y_ACTION_SCALE_RANGE.clamp(scale)); + } + }; +} diff --git a/packages/SystemUI/src/com/android/systemui/accessibility/WindowMagnification.java b/packages/SystemUI/src/com/android/systemui/accessibility/WindowMagnification.java index 3653bc80e8ad..64a8898fc569 100644 --- a/packages/SystemUI/src/com/android/systemui/accessibility/WindowMagnification.java +++ b/packages/SystemUI/src/com/android/systemui/accessibility/WindowMagnification.java @@ -16,6 +16,7 @@ package com.android.systemui.accessibility; +import static android.provider.Settings.Secure.ACCESSIBILITY_MAGNIFICATION_MODE_WINDOW; import static android.view.WindowManager.LayoutParams.TYPE_ACCESSIBILITY_MAGNIFICATION_OVERLAY; import static com.android.systemui.shared.system.QuickStepContract.SYSUI_STATE_MAGNIFICATION_OVERLAP; @@ -55,8 +56,7 @@ import javax.inject.Inject; * when {@code IStatusBar#requestWindowMagnificationConnection(boolean)} is called. */ @SysUISingleton -public class WindowMagnification implements CoreStartable, WindowMagnifierCallback, - CommandQueue.Callbacks { +public class WindowMagnification implements CoreStartable, CommandQueue.Callbacks { private static final String TAG = "WindowMagnification"; private final ModeSwitchesController mModeSwitchesController; @@ -113,11 +113,45 @@ public class WindowMagnification implements CoreStartable, WindowMagnifierCallba @VisibleForTesting DisplayIdIndexSupplier<WindowMagnificationController> mMagnificationControllerSupplier; + private static class SettingsSupplier extends + DisplayIdIndexSupplier<MagnificationSettingsController> { + + private final Context mContext; + private final MagnificationSettingsController.Callback mSettingsControllerCallback; + private final SecureSettings mSecureSettings; + + SettingsSupplier(Context context, + MagnificationSettingsController.Callback settingsControllerCallback, + DisplayManager displayManager, + SecureSettings secureSettings) { + super(displayManager); + mContext = context; + mSettingsControllerCallback = settingsControllerCallback; + mSecureSettings = secureSettings; + } + + @Override + protected MagnificationSettingsController createInstance(Display display) { + final Context windowContext = mContext.createWindowContext(display, + TYPE_ACCESSIBILITY_MAGNIFICATION_OVERLAY, /* options */ null); + windowContext.setTheme(com.android.systemui.R.style.Theme_SystemUI); + return new MagnificationSettingsController( + windowContext, + new SfVsyncFrameCallbackProvider(), + mSettingsControllerCallback, + mSecureSettings); + } + } + + @VisibleForTesting + DisplayIdIndexSupplier<MagnificationSettingsController> mMagnificationSettingsSupplier; + @Inject public WindowMagnification(Context context, @Main Handler mainHandler, CommandQueue commandQueue, ModeSwitchesController modeSwitchesController, SysUiState sysUiState, OverviewProxyService overviewProxyService, - SecureSettings secureSettings, DisplayTracker displayTracker) { + SecureSettings secureSettings, DisplayTracker displayTracker, + DisplayManager displayManager) { mContext = context; mHandler = mainHandler; mAccessibilityManager = mContext.getSystemService(AccessibilityManager.class); @@ -127,8 +161,10 @@ public class WindowMagnification implements CoreStartable, WindowMagnifierCallba mOverviewProxyService = overviewProxyService; mDisplayTracker = displayTracker; mMagnificationControllerSupplier = new ControllerSupplier(context, - mHandler, this, context.getSystemService(DisplayManager.class), sysUiState, - secureSettings); + mHandler, mWindowMagnifierCallback, + displayManager, sysUiState, secureSettings); + mMagnificationSettingsSupplier = new SettingsSupplier(context, + mMagnificationSettingsControllerCallback, displayManager, secureSettings); } @Override @@ -209,45 +245,179 @@ public class WindowMagnification implements CoreStartable, WindowMagnifierCallba } } - @Override - public void onWindowMagnifierBoundsChanged(int displayId, Rect frame) { - if (mWindowMagnificationConnectionImpl != null) { - mWindowMagnificationConnectionImpl.onWindowMagnifierBoundsChanged(displayId, frame); + @MainThread + void showMagnificationSettingsPanel(int displayId) { + final MagnificationSettingsController magnificationSettingsController = + mMagnificationSettingsSupplier.get(displayId); + if (magnificationSettingsController != null) { + magnificationSettingsController.showMagnificationSettings(); } } - @Override - public void onSourceBoundsChanged(int displayId, Rect sourceBounds) { - if (mWindowMagnificationConnectionImpl != null) { - mWindowMagnificationConnectionImpl.onSourceBoundsChanged(displayId, sourceBounds); + @MainThread + void hideMagnificationSettingsPanel(int displayId) { + final MagnificationSettingsController magnificationSettingsController = + mMagnificationSettingsSupplier.get(displayId); + if (magnificationSettingsController != null) { + magnificationSettingsController.closeMagnificationSettings(); } } - @Override - public void onPerformScaleAction(int displayId, float scale) { - if (mWindowMagnificationConnectionImpl != null) { - mWindowMagnificationConnectionImpl.onPerformScaleAction(displayId, scale); + boolean isMagnificationSettingsPanelShowing(int displayId) { + final MagnificationSettingsController magnificationSettingsController = + mMagnificationSettingsSupplier.get(displayId); + if (magnificationSettingsController != null) { + return magnificationSettingsController.isMagnificationSettingsShowing(); } + return false; } - @Override - public void onAccessibilityActionPerformed(int displayId) { - if (mWindowMagnificationConnectionImpl != null) { - mWindowMagnificationConnectionImpl.onAccessibilityActionPerformed(displayId); + @MainThread + void showMagnificationButton(int displayId, int magnificationMode) { + // not to show mode switch button if settings panel is already showing to + // prevent settings panel be covered by the button. + if (isMagnificationSettingsPanelShowing(displayId)) { + return; } + mModeSwitchesController.showButton(displayId, magnificationMode); } - @Override - public void onMove(int displayId) { - if (mWindowMagnificationConnectionImpl != null) { - mWindowMagnificationConnectionImpl.onMove(displayId); + @MainThread + void removeMagnificationButton(int displayId) { + mModeSwitchesController.removeButton(displayId); + } + + @VisibleForTesting + final WindowMagnifierCallback mWindowMagnifierCallback = new WindowMagnifierCallback() { + @Override + public void onWindowMagnifierBoundsChanged(int displayId, Rect frame) { + if (mWindowMagnificationConnectionImpl != null) { + mWindowMagnificationConnectionImpl.onWindowMagnifierBoundsChanged(displayId, frame); + } + } + + @Override + public void onSourceBoundsChanged(int displayId, Rect sourceBounds) { + if (mWindowMagnificationConnectionImpl != null) { + mWindowMagnificationConnectionImpl.onSourceBoundsChanged(displayId, sourceBounds); + } + } + + @Override + public void onPerformScaleAction(int displayId, float scale) { + if (mWindowMagnificationConnectionImpl != null) { + mWindowMagnificationConnectionImpl.onPerformScaleAction(displayId, scale); + } + } + + @Override + public void onAccessibilityActionPerformed(int displayId) { + if (mWindowMagnificationConnectionImpl != null) { + mWindowMagnificationConnectionImpl.onAccessibilityActionPerformed(displayId); + } + } + + @Override + public void onMove(int displayId) { + if (mWindowMagnificationConnectionImpl != null) { + mWindowMagnificationConnectionImpl.onMove(displayId); + } + } + + @Override + public void onClickSettingsButton(int displayId) { + mHandler.post(() -> showMagnificationSettingsPanel(displayId)); + } + }; + + @VisibleForTesting + final MagnificationSettingsController.Callback mMagnificationSettingsControllerCallback = + new MagnificationSettingsController.Callback() { + @Override + public void onSetMagnifierSize(int displayId, int index) { + mHandler.post(() -> onSetMagnifierSizeInternal(displayId, index)); + } + + @Override + public void onSetDiagonalScrolling(int displayId, boolean enable) { + mHandler.post(() -> onSetDiagonalScrollingInternal(displayId, enable)); + } + + @Override + public void onEditMagnifierSizeMode(int displayId, boolean enable) { + mHandler.post(() -> onEditMagnifierSizeModeInternal(displayId, enable)); + } + + @Override + public void onMagnifierScale(int displayId, float scale) { + if (mWindowMagnificationConnectionImpl != null) { + mWindowMagnificationConnectionImpl.onPerformScaleAction(displayId, scale); + } + } + + @Override + public void onModeSwitch(int displayId, int newMode) { + mHandler.post(() -> onModeSwitchInternal(displayId, newMode)); + } + + @Override + public void onSettingsPanelVisibilityChanged(int displayId, boolean shown) { + mHandler.post(() -> onSettingsPanelVisibilityChangedInternal(displayId, shown)); + } + }; + + @MainThread + private void onSetMagnifierSizeInternal(int displayId, int index) { + final WindowMagnificationController windowMagnificationController = + mMagnificationControllerSupplier.get(displayId); + if (windowMagnificationController != null) { + windowMagnificationController.changeMagnificationSize(index); } } - @Override - public void onModeSwitch(int displayId, int newMode) { - if (mWindowMagnificationConnectionImpl != null) { - mWindowMagnificationConnectionImpl.onChangeMagnificationMode(displayId, newMode); + @MainThread + private void onSetDiagonalScrollingInternal(int displayId, boolean enable) { + final WindowMagnificationController windowMagnificationController = + mMagnificationControllerSupplier.get(displayId); + if (windowMagnificationController != null) { + windowMagnificationController.setDiagonalScrolling(enable); + } + } + + @MainThread + private void onEditMagnifierSizeModeInternal(int displayId, boolean enable) { + final WindowMagnificationController windowMagnificationController = + mMagnificationControllerSupplier.get(displayId); + if (windowMagnificationController != null && windowMagnificationController.isActivated()) { + windowMagnificationController.setEditMagnifierSizeMode(enable); + } + } + + @MainThread + private void onModeSwitchInternal(int displayId, int newMode) { + final WindowMagnificationController windowMagnificationController = + mMagnificationControllerSupplier.get(displayId); + final boolean isWindowMagnifierActivated = windowMagnificationController.isActivated(); + final boolean isSwitchToWindowMode = (newMode == ACCESSIBILITY_MAGNIFICATION_MODE_WINDOW); + final boolean changed = isSwitchToWindowMode ^ isWindowMagnifierActivated; + if (changed) { + final MagnificationSettingsController magnificationSettingsController = + mMagnificationSettingsSupplier.get(displayId); + if (magnificationSettingsController != null) { + magnificationSettingsController.closeMagnificationSettings(); + } + if (mWindowMagnificationConnectionImpl != null) { + mWindowMagnificationConnectionImpl.onChangeMagnificationMode(displayId, newMode); + } + } + } + + @MainThread + private void onSettingsPanelVisibilityChangedInternal(int displayId, boolean shown) { + final WindowMagnificationController windowMagnificationController = + mMagnificationControllerSupplier.get(displayId); + if (windowMagnificationController != null) { + windowMagnificationController.updateDragHandleResourcesIfNeeded(shown); } } @@ -270,7 +440,7 @@ public class WindowMagnification implements CoreStartable, WindowMagnifierCallba private void setWindowMagnificationConnection() { if (mWindowMagnificationConnectionImpl == null) { mWindowMagnificationConnectionImpl = new WindowMagnificationConnectionImpl(this, - mHandler, mModeSwitchesController); + mHandler); } mModeSwitchesController.setSwitchListenerDelegate( mWindowMagnificationConnectionImpl::onChangeMagnificationMode); diff --git a/packages/SystemUI/src/com/android/systemui/accessibility/WindowMagnificationConnectionImpl.java b/packages/SystemUI/src/com/android/systemui/accessibility/WindowMagnificationConnectionImpl.java index aa684faee5ab..18e576e3e611 100644 --- a/packages/SystemUI/src/com/android/systemui/accessibility/WindowMagnificationConnectionImpl.java +++ b/packages/SystemUI/src/com/android/systemui/accessibility/WindowMagnificationConnectionImpl.java @@ -39,13 +39,11 @@ class WindowMagnificationConnectionImpl extends IWindowMagnificationConnection.S private IWindowMagnificationConnectionCallback mConnectionCallback; private final WindowMagnification mWindowMagnification; private final Handler mHandler; - private final ModeSwitchesController mModeSwitchesController; WindowMagnificationConnectionImpl(@NonNull WindowMagnification windowMagnification, - @Main Handler mainHandler, ModeSwitchesController modeSwitchesController) { + @Main Handler mainHandler) { mWindowMagnification = windowMagnification; mHandler = mainHandler; - mModeSwitchesController = modeSwitchesController; } @Override @@ -86,13 +84,13 @@ class WindowMagnificationConnectionImpl extends IWindowMagnificationConnection.S @Override public void showMagnificationButton(int displayId, int magnificationMode) { mHandler.post( - () -> mModeSwitchesController.showButton(displayId, magnificationMode)); + () -> mWindowMagnification.showMagnificationButton(displayId, magnificationMode)); } @Override public void removeMagnificationButton(int displayId) { mHandler.post( - () -> mModeSwitchesController.removeButton(displayId)); + () -> mWindowMagnification.removeMagnificationButton(displayId)); } @Override diff --git a/packages/SystemUI/src/com/android/systemui/accessibility/WindowMagnificationController.java b/packages/SystemUI/src/com/android/systemui/accessibility/WindowMagnificationController.java index 57c99187c302..572458c6e8eb 100644 --- a/packages/SystemUI/src/com/android/systemui/accessibility/WindowMagnificationController.java +++ b/packages/SystemUI/src/com/android/systemui/accessibility/WindowMagnificationController.java @@ -210,9 +210,6 @@ class WindowMagnificationController implements View.OnTouchListener, SurfaceHold private boolean mOverlapWithGestureInsets; private boolean mIsDragging; - // Window Magnification Setting view - private WindowMagnificationSettings mWindowMagnificationSettings; - private static final int MAX_HORIZONTAL_MOVE_ANGLE = 50; private static final int HORIZONTAL = 1; private static final int VERTICAL = 0; @@ -279,10 +276,6 @@ class WindowMagnificationController implements View.OnTouchListener, SurfaceHold mGestureDetector = new MagnificationGestureDetector(mContext, handler, this); - mWindowMagnificationSettings = - new WindowMagnificationSettings(mContext, mWindowMagnificationSettingsCallback, - mSfVsyncFrameProvider, secureSettings); - // Initialize listeners. mMirrorViewRunnable = () -> { if (mMirrorView != null) { @@ -311,7 +304,7 @@ class WindowMagnificationController implements View.OnTouchListener, SurfaceHold mMirrorViewGeometryVsyncCallback = l -> { - if (isWindowVisible() && mMirrorSurface != null && calculateSourceBounds( + if (isActivated() && mMirrorSurface != null && calculateSourceBounds( mMagnificationFrame, mScale)) { // The final destination for the magnification surface should be at 0,0 // since the ViewRootImpl's position will change @@ -328,7 +321,7 @@ class WindowMagnificationController implements View.OnTouchListener, SurfaceHold } }; mUpdateStateDescriptionRunnable = () -> { - if (isWindowVisible()) { + if (isActivated()) { mMirrorView.setStateDescription(formatStateDescription(mScale)); } }; @@ -368,25 +361,23 @@ class WindowMagnificationController implements View.OnTouchListener, SurfaceHold return false; } - @VisibleForTesting void changeMagnificationSize(@MagnificationSize int index) { final int initSize = Math.min(mWindowBounds.width(), mWindowBounds.height()) / 3; int size = (int) (initSize * MAGNIFICATION_SCALE_OPTIONS[index]); setWindowSize(size, size); } - @VisibleForTesting void setEditMagnifierSizeMode(boolean enable) { mEditSizeEnable = enable; applyResourcesValues(); - if (isWindowVisible()) { + if (isActivated()) { updateDimensions(); applyTapExcludeRegion(); } } - private void setDiagonalScrolling(boolean enable) { + void setDiagonalScrolling(boolean enable) { mAllowDiagonalScrolling = enable; } @@ -403,22 +394,14 @@ class WindowMagnificationController implements View.OnTouchListener, SurfaceHold mAnimationController.deleteWindowMagnification(animationCallback); } - void deleteWindowMagnification() { - deleteWindowMagnification(/* closeSettingPanel= */ true); - } - /** * Deletes the magnification window. */ - void deleteWindowMagnification(boolean closeSettingPanel) { - if (!isWindowVisible()) { + void deleteWindowMagnification() { + if (!isActivated()) { return; } - if (closeSettingPanel) { - closeMagnificationSettings(); - } - if (mMirrorSurface != null) { mTransaction.remove(mMirrorSurface).apply(); mMirrorSurface = null; @@ -453,7 +436,6 @@ class WindowMagnificationController implements View.OnTouchListener, SurfaceHold final int configDiff = newConfig.diff(mConfiguration); mConfiguration.setTo(newConfig); onConfigurationChanged(configDiff); - mWindowMagnificationSettings.onConfigurationChanged(configDiff); } @Override @@ -494,8 +476,8 @@ class WindowMagnificationController implements View.OnTouchListener, SurfaceHold // Recreate the window again to correct the window appearance due to density or // window size changed not caused by rotation. - if (isWindowVisible() && reCreateWindow) { - deleteWindowMagnification(/* closeSettingPanel= */ false); + if (isActivated() && reCreateWindow) { + deleteWindowMagnification(); enableWindowMagnificationInternal(Float.NaN, Float.NaN, Float.NaN); } } @@ -532,7 +514,7 @@ class WindowMagnificationController implements View.OnTouchListener, SurfaceHold } private void updateAccessibilityWindowTitleIfNeeded() { - if (!isWindowVisible()) return; + if (!isActivated()) return; LayoutParams params = (LayoutParams) mMirrorView.getLayoutParams(); params.accessibilityTitle = getAccessibilityWindowTitle(); mWm.updateViewLayout(mMirrorView, params); @@ -703,23 +685,6 @@ class WindowMagnificationController implements View.OnTouchListener, SurfaceHold } } - private void showMagnificationSettings() { - if (mWindowMagnificationSettings != null) { - mWindowMagnificationSettings.showSettingPanel(); - } - } - - private void closeMagnificationSettings() { - if (mWindowMagnificationSettings != null) { - mWindowMagnificationSettings.hideSettingPanel(); - } - } - - @VisibleForTesting - WindowMagnificationSettings getMagnificationSettings() { - return mWindowMagnificationSettings; - } - /** * Sets the window size with given width and height in pixels without changing the * window center. The width or the height will be clamped in the range @@ -845,7 +810,7 @@ class WindowMagnificationController implements View.OnTouchListener, SurfaceHold * {@link #mMagnificationFrame}. */ private void updateMirrorViewLayout(boolean computeWindowSize) { - if (!isWindowVisible()) { + if (!isActivated()) { return; } final int maxMirrorViewX = mWindowBounds.width() - mMirrorView.getWidth(); @@ -1018,7 +983,7 @@ class WindowMagnificationController implements View.OnTouchListener, SurfaceHold } private void updateSysUIState(boolean force) { - final boolean overlap = isWindowVisible() && mSystemGestureTop > 0 + final boolean overlap = isActivated() && mSystemGestureTop > 0 && mMirrorViewBounds.bottom > mSystemGestureTop; if (force || overlap != mOverlapWithGestureInsets) { mOverlapWithGestureInsets = overlap; @@ -1113,7 +1078,7 @@ class WindowMagnificationController implements View.OnTouchListener, SurfaceHold deleteWindowMagnification(); return; } - if (!isWindowVisible()) { + if (!isActivated()) { onConfigurationChanged(mResources.getConfiguration()); mContext.registerComponentCallbacks(this); } @@ -1138,7 +1103,7 @@ class WindowMagnificationController implements View.OnTouchListener, SurfaceHold calculateMagnificationFrameBoundary(); updateMagnificationFramePosition((int) offsetX, (int) offsetY); - if (!isWindowVisible()) { + if (!isActivated()) { createMirrorWindow(); showControls(); applyResourcesValues(); @@ -1147,13 +1112,19 @@ class WindowMagnificationController implements View.OnTouchListener, SurfaceHold } } + // The magnifier is activated when the window is visible, + // and the window is visible when it is existed. + boolean isActivated() { + return mMirrorView != null; + } + /** * Sets the scale of the magnified region if it's visible. * * @param scale the target scale, or {@link Float#NaN} to leave unchanged */ void setScale(float scale) { - if (mAnimationController.isAnimating() || !isWindowVisible() || mScale == scale) { + if (mAnimationController.isAnimating() || !isActivated() || mScale == scale) { return; } @@ -1216,7 +1187,7 @@ class WindowMagnificationController implements View.OnTouchListener, SurfaceHold * @return {@link Float#NaN} if the window is invisible. */ float getScale() { - return isWindowVisible() ? mScale : Float.NaN; + return isActivated() ? mScale : Float.NaN; } /** @@ -1225,7 +1196,7 @@ class WindowMagnificationController implements View.OnTouchListener, SurfaceHold * @return the X coordinate. {@link Float#NaN} if the window is invisible. */ float getCenterX() { - return isWindowVisible() ? mMagnificationFrame.exactCenterX() : Float.NaN; + return isActivated() ? mMagnificationFrame.exactCenterX() : Float.NaN; } /** @@ -1234,12 +1205,7 @@ class WindowMagnificationController implements View.OnTouchListener, SurfaceHold * @return the Y coordinate. {@link Float#NaN} if the window is invisible. */ float getCenterY() { - return isWindowVisible() ? mMagnificationFrame.exactCenterY() : Float.NaN; - } - - //The window is visible when it is existed. - private boolean isWindowVisible() { - return mMirrorView != null; + return isActivated() ? mMagnificationFrame.exactCenterY() : Float.NaN; } private CharSequence formatStateDescription(float scale) { @@ -1273,7 +1239,7 @@ class WindowMagnificationController implements View.OnTouchListener, SurfaceHold private void handleSingleTap(View view) { int id = view.getId(); if (id == R.id.drag_handle) { - showMagnificationSettings(); + mWindowMagnifierCallback.onClickSettingsButton(mDisplayId); } else if (id == R.id.close_button) { setEditMagnifierSizeMode(false); } else { @@ -1379,40 +1345,6 @@ class WindowMagnificationController implements View.OnTouchListener, SurfaceHold == Configuration.SCREENLAYOUT_LAYOUTDIR_RTL; } - private WindowMagnificationSettingsCallback mWindowMagnificationSettingsCallback = - new WindowMagnificationSettingsCallback() { - @Override - public void onSetDiagonalScrolling(boolean enable) { - setDiagonalScrolling(enable); - } - - @Override - public void onModeSwitch(int newMode) { - mWindowMagnifierCallback.onModeSwitch(mDisplayId, newMode); - } - - @Override - public void onSetMagnifierSize(@MagnificationSize int index) { - changeMagnificationSize(index); - } - - @Override - public void onEditMagnifierSizeMode(boolean enable) { - setEditMagnifierSizeMode(enable); - } - - @Override - public void onMagnifierScale(float scale) { - mWindowMagnifierCallback.onPerformScaleAction(mDisplayId, - A11Y_ACTION_SCALE_RANGE.clamp(scale)); - } - - @Override - public void onSettingsPanelVisibilityChanged(boolean shown) { - updateDragHandleResourcesIfNeeded(/* settingsPanelIsShown= */ shown); - } - }; - @Override public boolean onStart(float x, float y) { mIsDragging = true; @@ -1449,7 +1381,7 @@ class WindowMagnificationController implements View.OnTouchListener, SurfaceHold } } - private void updateDragHandleResourcesIfNeeded(boolean settingsPanelIsShown) { + void updateDragHandleResourcesIfNeeded(boolean settingsPanelIsShown) { mDragView.setBackground(mContext.getResources().getDrawable(settingsPanelIsShown ? R.drawable.accessibility_window_magnification_drag_handle_background_change : R.drawable.accessibility_window_magnification_drag_handle_background)); @@ -1476,11 +1408,11 @@ class WindowMagnificationController implements View.OnTouchListener, SurfaceHold pw.println(" mOverlapWithGestureInsets:" + mOverlapWithGestureInsets); pw.println(" mScale:" + mScale); pw.println(" mWindowBounds:" + mWindowBounds); - pw.println(" mMirrorViewBounds:" + (isWindowVisible() ? mMirrorViewBounds : "empty")); + pw.println(" mMirrorViewBounds:" + (isActivated() ? mMirrorViewBounds : "empty")); pw.println(" mMagnificationFrameBoundary:" - + (isWindowVisible() ? mMagnificationFrameBoundary : "empty")); + + (isActivated() ? mMagnificationFrameBoundary : "empty")); pw.println(" mMagnificationFrame:" - + (isWindowVisible() ? mMagnificationFrame : "empty")); + + (isActivated() ? mMagnificationFrame : "empty")); pw.println(" mSourceBounds:" + (mSourceBounds.isEmpty() ? "empty" : mSourceBounds)); pw.println(" mSystemGestureTop:" + mSystemGestureTop); diff --git a/packages/SystemUI/src/com/android/systemui/accessibility/WindowMagnificationSettings.java b/packages/SystemUI/src/com/android/systemui/accessibility/WindowMagnificationSettings.java index d9f5544c39b9..f3a9961cee90 100644 --- a/packages/SystemUI/src/com/android/systemui/accessibility/WindowMagnificationSettings.java +++ b/packages/SystemUI/src/com/android/systemui/accessibility/WindowMagnificationSettings.java @@ -322,6 +322,10 @@ class WindowMagnificationSettings implements MagnificationGestureDetector.OnGest showSettingPanel(true); } + public boolean isSettingPanelShowing() { + return mIsVisible; + } + public void setScaleSeekbar(float scale) { setSeekbarProgress(scale); } diff --git a/packages/SystemUI/src/com/android/systemui/accessibility/WindowMagnifierCallback.java b/packages/SystemUI/src/com/android/systemui/accessibility/WindowMagnifierCallback.java index 19caaf431e0a..e18161d658a8 100644 --- a/packages/SystemUI/src/com/android/systemui/accessibility/WindowMagnifierCallback.java +++ b/packages/SystemUI/src/com/android/systemui/accessibility/WindowMagnifierCallback.java @@ -62,10 +62,9 @@ interface WindowMagnifierCallback { void onMove(int displayId); /** - * Called when magnification mode changed. + * Called when magnification settings button clicked. * * @param displayId The logical display id. - * @param newMode Magnification mode. */ - void onModeSwitch(int displayId, int newMode); + void onClickSettingsButton(int displayId); } diff --git a/packages/SystemUI/tests/src/com/android/systemui/accessibility/IWindowMagnificationConnectionTest.java b/packages/SystemUI/tests/src/com/android/systemui/accessibility/IWindowMagnificationConnectionTest.java index 213ce9e4d6a1..f32c0eb495ba 100644 --- a/packages/SystemUI/tests/src/com/android/systemui/accessibility/IWindowMagnificationConnectionTest.java +++ b/packages/SystemUI/tests/src/com/android/systemui/accessibility/IWindowMagnificationConnectionTest.java @@ -94,7 +94,7 @@ public class IWindowMagnificationConnectionTest extends SysuiTestCase { mWindowMagnification = new WindowMagnification(getContext(), getContext().getMainThreadHandler(), mCommandQueue, mModeSwitchesController, mSysUiState, mOverviewProxyService, mSecureSettings, - mDisplayTracker); + mDisplayTracker, getContext().getSystemService(DisplayManager.class)); mWindowMagnification.mMagnificationControllerSupplier = new FakeControllerSupplier( mContext.getSystemService(DisplayManager.class)); diff --git a/packages/SystemUI/tests/src/com/android/systemui/accessibility/MagnificationSettingsControllerTest.java b/packages/SystemUI/tests/src/com/android/systemui/accessibility/MagnificationSettingsControllerTest.java new file mode 100644 index 000000000000..665246bd7f7d --- /dev/null +++ b/packages/SystemUI/tests/src/com/android/systemui/accessibility/MagnificationSettingsControllerTest.java @@ -0,0 +1,154 @@ +/* + * Copyright (C) 2023 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.systemui.accessibility; + +import static android.provider.Settings.Secure.ACCESSIBILITY_MAGNIFICATION_MODE_FULLSCREEN; + +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.verify; + +import android.content.pm.ActivityInfo; +import android.testing.AndroidTestingRunner; +import android.testing.TestableLooper; + +import androidx.test.filters.SmallTest; + +import com.android.internal.graphics.SfVsyncFrameCallbackProvider; +import com.android.systemui.SysuiTestCase; +import com.android.systemui.accessibility.WindowMagnificationSettings.MagnificationSize; +import com.android.systemui.util.settings.SecureSettings; + +import org.junit.After; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; + +@SmallTest +@RunWith(AndroidTestingRunner.class) +/** Tests the MagnificationSettingsController. */ +@TestableLooper.RunWithLooper(setAsMainLooper = true) +public class MagnificationSettingsControllerTest extends SysuiTestCase { + + private MagnificationSettingsController mMagnificationSettingsController; + @Mock + private MagnificationSettingsController.Callback mMagnificationSettingControllerCallback; + + @Mock + private WindowMagnificationSettings mWindowMagnificationSettings; + + @Mock + private SfVsyncFrameCallbackProvider mSfVsyncFrameProvider; + @Mock + private SecureSettings mSecureSettings; + + @Before + public void setUp() { + MockitoAnnotations.initMocks(this); + mMagnificationSettingsController = new MagnificationSettingsController( + mContext, mSfVsyncFrameProvider, + mMagnificationSettingControllerCallback, mSecureSettings, + mWindowMagnificationSettings); + } + + @After + public void tearDown() { + mMagnificationSettingsController.closeMagnificationSettings(); + } + + @Test + public void testShowSettingsPanel() { + mMagnificationSettingsController.showMagnificationSettings(); + + verify(mWindowMagnificationSettings).showSettingPanel(); + } + + @Test + public void testHideSettingsPanel() { + mMagnificationSettingsController.closeMagnificationSettings(); + + verify(mWindowMagnificationSettings).hideSettingPanel(); + } + + @Test + public void testOnConfigurationChanged_notifySettingsPanel() { + mMagnificationSettingsController.onConfigurationChanged(ActivityInfo.CONFIG_DENSITY); + + verify(mWindowMagnificationSettings).onConfigurationChanged(ActivityInfo.CONFIG_DENSITY); + } + + @Test + public void testPanelOnSetDiagonalScrolling_delegateToCallback() { + final boolean enable = true; + mMagnificationSettingsController.mWindowMagnificationSettingsCallback + .onSetDiagonalScrolling(enable); + + verify(mMagnificationSettingControllerCallback).onSetDiagonalScrolling( + eq(mContext.getDisplayId()), eq(enable)); + } + + @Test + public void testPanelOnModeSwitch_delegateToCallback() { + final int newMode = ACCESSIBILITY_MAGNIFICATION_MODE_FULLSCREEN; + mMagnificationSettingsController.mWindowMagnificationSettingsCallback + .onModeSwitch(newMode); + + verify(mMagnificationSettingControllerCallback).onModeSwitch( + eq(mContext.getDisplayId()), eq(newMode)); + } + + @Test + public void testPanelOnSettingsPanelVisibilityChanged_delegateToCallback() { + final boolean shown = true; + mMagnificationSettingsController.mWindowMagnificationSettingsCallback + .onSettingsPanelVisibilityChanged(shown); + + verify(mMagnificationSettingControllerCallback).onSettingsPanelVisibilityChanged( + eq(mContext.getDisplayId()), eq(shown)); + } + + @Test + public void testPanelOnSetMagnifierSize_delegateToCallback() { + final @MagnificationSize int index = MagnificationSize.SMALL; + mMagnificationSettingsController.mWindowMagnificationSettingsCallback + .onSetMagnifierSize(index); + + verify(mMagnificationSettingControllerCallback).onSetMagnifierSize( + eq(mContext.getDisplayId()), eq(index)); + } + + @Test + public void testPanelOnEditMagnifierSizeMode_delegateToCallback() { + final boolean enable = true; + mMagnificationSettingsController.mWindowMagnificationSettingsCallback + .onEditMagnifierSizeMode(enable); + + verify(mMagnificationSettingControllerCallback).onEditMagnifierSizeMode( + eq(mContext.getDisplayId()), eq(enable)); + } + + @Test + public void testPanelOnMagnifierScale_delegateToCallback() { + final float scale = 3.0f; + mMagnificationSettingsController.mWindowMagnificationSettingsCallback + .onMagnifierScale(scale); + + verify(mMagnificationSettingControllerCallback).onMagnifierScale( + eq(mContext.getDisplayId()), eq(scale)); + } +} diff --git a/packages/SystemUI/tests/src/com/android/systemui/accessibility/WindowMagnificationAnimationControllerTest.java b/packages/SystemUI/tests/src/com/android/systemui/accessibility/WindowMagnificationAnimationControllerTest.java index de152e4a93d8..b5e0df5d733c 100644 --- a/packages/SystemUI/tests/src/com/android/systemui/accessibility/WindowMagnificationAnimationControllerTest.java +++ b/packages/SystemUI/tests/src/com/android/systemui/accessibility/WindowMagnificationAnimationControllerTest.java @@ -790,7 +790,7 @@ public class WindowMagnificationAnimationControllerTest extends SysuiTestCase { // should move with both offsetX and offsetY without regrading offsetY/offsetX mInstrumentation.runOnMainSync( () -> { - mController.getMagnificationSettings().setDiagonalScrolling(true); + mController.setDiagonalScrolling(true); mController.moveWindowMagnifier(offsetX, offsetY); }); diff --git a/packages/SystemUI/tests/src/com/android/systemui/accessibility/WindowMagnificationControllerTest.java b/packages/SystemUI/tests/src/com/android/systemui/accessibility/WindowMagnificationControllerTest.java index 6e4a20aaf6fe..0978c824cb15 100644 --- a/packages/SystemUI/tests/src/com/android/systemui/accessibility/WindowMagnificationControllerTest.java +++ b/packages/SystemUI/tests/src/com/android/systemui/accessibility/WindowMagnificationControllerTest.java @@ -640,6 +640,10 @@ public class WindowMagnificationControllerTest extends SysuiTestCase { assertTrue( mirrorView.performAccessibilityAction(R.id.accessibility_action_move_left, null)); verify(mWindowMagnifierCallback, times(4)).onMove(eq(displayId)); + + assertTrue(mirrorView.performAccessibilityAction( + AccessibilityAction.ACTION_CLICK.getId(), null)); + verify(mWindowMagnifierCallback).onClickSettingsButton(eq(displayId)); } @Test diff --git a/packages/SystemUI/tests/src/com/android/systemui/accessibility/WindowMagnificationTest.java b/packages/SystemUI/tests/src/com/android/systemui/accessibility/WindowMagnificationTest.java index 583f2db20570..ac2cd7358f75 100644 --- a/packages/SystemUI/tests/src/com/android/systemui/accessibility/WindowMagnificationTest.java +++ b/packages/SystemUI/tests/src/com/android/systemui/accessibility/WindowMagnificationTest.java @@ -16,16 +16,22 @@ package com.android.systemui.accessibility; +import static android.provider.Settings.Secure.ACCESSIBILITY_MAGNIFICATION_MODE_FULLSCREEN; +import static android.provider.Settings.Secure.ACCESSIBILITY_MAGNIFICATION_MODE_WINDOW; + +import static com.android.systemui.accessibility.WindowMagnificationSettings.MagnificationSize; import static com.android.systemui.recents.OverviewProxyService.OverviewProxyListener; import static com.android.systemui.shared.system.QuickStepContract.SYSUI_STATE_MAGNIFICATION_OVERLAP; import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.anyBoolean; import static org.mockito.ArgumentMatchers.anyInt; +import static org.mockito.ArgumentMatchers.eq; import static org.mockito.ArgumentMatchers.isNull; import static org.mockito.ArgumentMatchers.notNull; import static org.mockito.Mockito.doAnswer; import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.never; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; @@ -80,6 +86,11 @@ public class WindowMagnificationTest extends SysuiTestCase { private OverviewProxyListener mOverviewProxyListener; private FakeDisplayTracker mDisplayTracker = new FakeDisplayTracker(mContext); + @Mock + private WindowMagnificationController mWindowMagnificationController; + @Mock + private MagnificationSettingsController mMagnificationSettingsController; + @Before public void setUp() throws Exception { MockitoAnnotations.initMocks(this); @@ -96,7 +107,12 @@ public class WindowMagnificationTest extends SysuiTestCase { mCommandQueue = new CommandQueue(getContext(), mDisplayTracker); mWindowMagnification = new WindowMagnification(getContext(), getContext().getMainThreadHandler(), mCommandQueue, mModeSwitchesController, - mSysUiState, mOverviewProxyService, mSecureSettings, mDisplayTracker); + mSysUiState, mOverviewProxyService, mSecureSettings, mDisplayTracker, + getContext().getSystemService(DisplayManager.class)); + mWindowMagnification.mMagnificationControllerSupplier = new FakeControllerSupplier( + mContext.getSystemService(DisplayManager.class), mWindowMagnificationController); + mWindowMagnification.mMagnificationSettingsSupplier = new FakeSettingsSupplier( + mContext.getSystemService(DisplayManager.class), mMagnificationSettingsController); mWindowMagnification.start(); final ArgumentCaptor<OverviewProxyListener> listenerArgumentCaptor = @@ -127,7 +143,8 @@ public class WindowMagnificationTest extends SysuiTestCase { mCommandQueue.requestWindowMagnificationConnection(true); waitForIdleSync(); - mWindowMagnification.onWindowMagnifierBoundsChanged(TEST_DISPLAY, testBounds); + mWindowMagnification.mWindowMagnifierCallback + .onWindowMagnifierBoundsChanged(TEST_DISPLAY, testBounds); verify(mConnectionCallback).onWindowMagnifierBoundsChanged(TEST_DISPLAY, testBounds); } @@ -138,7 +155,8 @@ public class WindowMagnificationTest extends SysuiTestCase { mCommandQueue.requestWindowMagnificationConnection(true); waitForIdleSync(); - mWindowMagnification.onPerformScaleAction(TEST_DISPLAY, newScale); + mWindowMagnification.mWindowMagnifierCallback + .onPerformScaleAction(TEST_DISPLAY, newScale); verify(mConnectionCallback).onPerformScaleAction(TEST_DISPLAY, newScale); } @@ -148,7 +166,8 @@ public class WindowMagnificationTest extends SysuiTestCase { mCommandQueue.requestWindowMagnificationConnection(true); waitForIdleSync(); - mWindowMagnification.onAccessibilityActionPerformed(TEST_DISPLAY); + mWindowMagnification.mWindowMagnifierCallback + .onAccessibilityActionPerformed(TEST_DISPLAY); verify(mConnectionCallback).onAccessibilityActionPerformed(TEST_DISPLAY); } @@ -158,21 +177,99 @@ public class WindowMagnificationTest extends SysuiTestCase { mCommandQueue.requestWindowMagnificationConnection(true); waitForIdleSync(); - mWindowMagnification.onMove(TEST_DISPLAY); + mWindowMagnification.mWindowMagnifierCallback.onMove(TEST_DISPLAY); verify(mConnectionCallback).onMove(TEST_DISPLAY); } @Test - public void onModeSwitch_enabled_notifyCallback() throws RemoteException { - final int magnificationModeFullScreen = 1; + public void onClickSettingsButton_enabled_showPanel() { + mWindowMagnification.mWindowMagnifierCallback.onClickSettingsButton(TEST_DISPLAY); + waitForIdleSync(); + + verify(mMagnificationSettingsController).showMagnificationSettings(); + } + + @Test + public void onSetMagnifierSize_delegateToMagnifier() { + final @MagnificationSize int index = MagnificationSize.SMALL; + mWindowMagnification.mMagnificationSettingsControllerCallback.onSetMagnifierSize( + TEST_DISPLAY, index); + waitForIdleSync(); + + verify(mWindowMagnificationController).changeMagnificationSize(eq(index)); + } + + @Test + public void onSetDiagonalScrolling_delegateToMagnifier() { + mWindowMagnification.mMagnificationSettingsControllerCallback.onSetDiagonalScrolling( + TEST_DISPLAY, /* enable= */ true); + waitForIdleSync(); + + verify(mWindowMagnificationController).setDiagonalScrolling(eq(true)); + } + + @Test + public void onEditMagnifierSizeMode_windowActivated_delegateToMagnifier() { + when(mWindowMagnificationController.isActivated()).thenReturn(true); + mWindowMagnification.mMagnificationSettingsControllerCallback.onEditMagnifierSizeMode( + TEST_DISPLAY, /* enable= */ true); + waitForIdleSync(); + + verify(mWindowMagnificationController).setEditMagnifierSizeMode(eq(true)); + } + + @Test + public void onMagnifierScale_notifyCallback() throws RemoteException { + mCommandQueue.requestWindowMagnificationConnection(true); + waitForIdleSync(); + final float scale = 3.0f; + mWindowMagnification.mMagnificationSettingsControllerCallback.onMagnifierScale( + TEST_DISPLAY, scale); + + verify(mConnectionCallback).onPerformScaleAction(eq(TEST_DISPLAY), eq(scale)); + } + + @Test + public void onModeSwitch_windowEnabledAndSwitchToFullscreen_hidePanelAndNotifyCallback() + throws RemoteException { + when(mWindowMagnificationController.isActivated()).thenReturn(true); + mCommandQueue.requestWindowMagnificationConnection(true); + waitForIdleSync(); + + mWindowMagnification.mMagnificationSettingsControllerCallback.onModeSwitch( + TEST_DISPLAY, ACCESSIBILITY_MAGNIFICATION_MODE_FULLSCREEN); + waitForIdleSync(); + + verify(mMagnificationSettingsController).closeMagnificationSettings(); + verify(mConnectionCallback).onChangeMagnificationMode(eq(TEST_DISPLAY), + eq(ACCESSIBILITY_MAGNIFICATION_MODE_FULLSCREEN)); + } + + @Test + public void onModeSwitch_switchToSameMode_doNothing() + throws RemoteException { + when(mWindowMagnificationController.isActivated()).thenReturn(true); mCommandQueue.requestWindowMagnificationConnection(true); waitForIdleSync(); - mWindowMagnification.onModeSwitch(TEST_DISPLAY, magnificationModeFullScreen); + mWindowMagnification.mMagnificationSettingsControllerCallback.onModeSwitch( + TEST_DISPLAY, ACCESSIBILITY_MAGNIFICATION_MODE_WINDOW); + waitForIdleSync(); + + verify(mMagnificationSettingsController, never()).closeMagnificationSettings(); + verify(mConnectionCallback, never()).onChangeMagnificationMode(eq(TEST_DISPLAY), + /* magnificationMode = */ anyInt()); + } + + @Test + public void onSettingsPanelVisibilityChanged_delegateToMagnifier() { + final boolean shown = false; + mWindowMagnification.mMagnificationSettingsControllerCallback + .onSettingsPanelVisibilityChanged(TEST_DISPLAY, shown); + waitForIdleSync(); - verify(mConnectionCallback).onChangeMagnificationMode(TEST_DISPLAY, - magnificationModeFullScreen); + verify(mWindowMagnificationController).updateDragHandleResourcesIfNeeded(eq(shown)); } @Test @@ -211,4 +308,21 @@ public class WindowMagnificationTest extends SysuiTestCase { return mController; } } + + private static class FakeSettingsSupplier extends + DisplayIdIndexSupplier<MagnificationSettingsController> { + + private final MagnificationSettingsController mController; + + FakeSettingsSupplier(DisplayManager displayManager, + MagnificationSettingsController controller) { + super(displayManager); + mController = controller; + } + + @Override + protected MagnificationSettingsController createInstance(Display display) { + return mController; + } + } } |