Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit b0fecc88 authored by Candice Lo's avatar Candice Lo
Browse files

refactor(magnification): Renaming WindowMagnificationManager class as... 

refactor(magnification): Renaming WindowMagnificationManager class as MagnificationConnectionManager

The class WindowMagnificationManager handles stuffs more than magnification window mode. Therefore, we would like to rename the class to improve the readability of our codebase and avoid confusion. Since the class targets at managing the magnification connection operations, we will name it MagnificationConnectionManager.

Bug: 310109308
Test: manually. Renaming the class
      atest MagnificationProcessorTest
      atest MagnificationControllerTest
      atest MagnificationConnectionManagerTest
      atest WindowMagnificationGestureHandlerTest
      atest AccessibilityManagerServiceTest
Flag: NA
Change-Id: Ie4d53ba63aa6d6cadf4cf455f1ece534a54cad0a
parent 9d36aab1

services/accessibility/java/com/android/server/accessibility/AccessibilityInputFilter.java

+1 −1
Original line number Diff line number Diff line
@@ -668,7 +668,7 @@ class AccessibilityInputFilter extends InputFilter implements EventStreamTransfo 
            final Context uiContext = displayContext.createWindowContext(

                    TYPE_ACCESSIBILITY_MAGNIFICATION_OVERLAY, null /* options */);

            magnificationGestureHandler = new WindowMagnificationGestureHandler(uiContext,

                    mAms.getWindowMagnificationMgr(), mAms.getTraceManager(),

                    mAms.getMagnificationConnectionManager(), mAms.getTraceManager(),

                    mAms.getMagnificationController(),

                    detectControlGestures,

                    detectTwoFingerTripleTap,

services/accessibility/java/com/android/server/accessibility/AccessibilityManagerService.java

+9 −9
Original line number Diff line number Diff line
@@ -158,10 +158,10 @@ import com.android.internal.util.Preconditions; 
import com.android.server.AccessibilityManagerInternal;

import com.android.server.LocalServices;

import com.android.server.SystemService;

import com.android.server.accessibility.magnification.MagnificationConnectionManager;

import com.android.server.accessibility.magnification.MagnificationController;

import com.android.server.accessibility.magnification.MagnificationProcessor;

import com.android.server.accessibility.magnification.MagnificationScaleProvider;

import com.android.server.accessibility.magnification.WindowMagnificationManager;

import com.android.server.inputmethod.InputMethodManagerInternal;

import com.android.server.pm.UserManagerInternal;

import com.android.server.policy.WindowManagerPolicy;
@@ -3442,7 +3442,7 @@ public class AccessibilityManagerService extends IAccessibilityManager.Stub 
                && (userState.getMagnificationCapabilitiesLocked()

                != Settings.Secure.ACCESSIBILITY_MAGNIFICATION_MODE_FULLSCREEN)

                || userHasMagnificationServicesLocked(userState);

        getWindowMagnificationMgr().requestConnection(connect);

        getMagnificationConnectionManager().requestConnection(connect);

    }



    /**
@@ -4122,17 +4122,17 @@ public class AccessibilityManagerService extends IAccessibilityManager.Stub 
        mSecurityPolicy.enforceCallingOrSelfPermission(

                android.Manifest.permission.STATUS_BAR_SERVICE);



        getWindowMagnificationMgr().setConnection(connection);

        getMagnificationConnectionManager().setConnection(connection);

    }



    /**

     * Getter of {@link WindowMagnificationManager}.

     * Getter of {@link MagnificationConnectionManager}.

     *

     * @return WindowMagnificationManager

     * @return MagnificationManager

     */

    public WindowMagnificationManager getWindowMagnificationMgr() {

    public MagnificationConnectionManager getMagnificationConnectionManager() {

        synchronized (mLock) {

            return mMagnificationController.getWindowMagnificationMgr();

            return mMagnificationController.getMagnificationConnectionManager();

        }

    }
@@ -4423,7 +4423,7 @@ public class AccessibilityManagerService extends IAccessibilityManager.Stub 
                pw.println();

            }

            pw.append("hasWindowMagnificationConnection=").append(

                    String.valueOf(getWindowMagnificationMgr().isConnected()));

                    String.valueOf(getMagnificationConnectionManager().isConnected()));

            pw.println();

            mMagnificationProcessor.dump(pw, getValidDisplayList());

            final int userCount = mUserStates.size();
@@ -5144,7 +5144,7 @@ public class AccessibilityManagerService extends IAccessibilityManager.Stub 


            for (int i = 0; i < displays.size(); i++) {

                final int displayId = displays.get(i).getDisplayId();

                getWindowMagnificationMgr().removeMagnificationButton(displayId);

                getMagnificationConnectionManager().removeMagnificationButton(displayId);

            }

        }

    }

services/accessibility/java/com/android/server/accessibility/magnification/WindowMagnificationManager.java→services/accessibility/java/com/android/server/accessibility/magnification/MagnificationConnectionManager.java

+31 −15
Original line number Diff line number Diff line
@@ -60,19 +60,19 @@ import java.lang.annotation.RetentionPolicy; 
import java.util.concurrent.atomic.AtomicLongFieldUpdater;



/**

 * A class to manipulate window magnification through {@link MagnificationConnectionWrapper}

 * A class to manipulate magnification through {@link MagnificationConnectionWrapper}

 * create by {@link #setConnection(IWindowMagnificationConnection)}. To set the connection with

 * SysUI, call {@code StatusBarManagerInternal#requestWindowMagnificationConnection(boolean)}.

 * The applied magnification scale is constrained by

 * {@link MagnificationScaleProvider#constrainScale(float)}

 */

public class WindowMagnificationManager implements

public class MagnificationConnectionManager implements

        PanningScalingHandler.MagnificationDelegate,

        WindowManagerInternal.AccessibilityControllerInternal.UiChangesForAccessibilityCallbacks {



    private static final boolean DBG = false;



    private static final String TAG = "WindowMagnificationMgr";

    private static final String TAG = "MagnificationConnectionManager";



    /**

     * Indicate that the magnification window is at the magnification center.
@@ -208,7 +208,7 @@ public class WindowMagnificationManager implements 
    private final AccessibilityTraceManager mTrace;

    private final MagnificationScaleProvider mScaleProvider;



    public WindowMagnificationManager(Context context, Object lock, @NonNull Callback callback,

    public MagnificationConnectionManager(Context context, Object lock, @NonNull Callback callback,

            AccessibilityTraceManager trace, MagnificationScaleProvider scaleProvider) {

        mContext = context;

        mLock = lock;
@@ -1040,7 +1040,7 @@ public class WindowMagnificationManager implements 
        private float mScale = MagnificationScaleProvider.MIN_SCALE;

        private boolean mEnabled;



        private final WindowMagnificationManager mWindowMagnificationManager;

        private final MagnificationConnectionManager mMagnificationConnectionManager;

        // Records the bounds of window magnification.

        private final Rect mBounds = new Rect();

        // The magnified bounds on the screen.
@@ -1058,11 +1058,15 @@ public class WindowMagnificationManager implements 
                        "mTrackingTypingFocusSumTime");

        private volatile long mTrackingTypingFocusSumTime = 0;



        WindowMagnifier(int displayId, WindowMagnificationManager windowMagnificationManager) {

        WindowMagnifier(int displayId,

                MagnificationConnectionManager magnificationConnectionManager) {

            mDisplayId = displayId;

            mWindowMagnificationManager = windowMagnificationManager;

            mMagnificationConnectionManager = magnificationConnectionManager;

        }



        // TODO(b/312324808): Investigating whether

        //  mMagnificationConnectionManager#enableWindowMagnificationInternal requires a sync lock

        @SuppressWarnings("GuardedBy")

        boolean enableWindowMagnificationInternal(float scale, float centerX, float centerY,

                @Nullable MagnificationAnimationCallback animationCallback,

                @WindowPosition int windowPosition, int id) {
@@ -1072,8 +1076,8 @@ public class WindowMagnificationManager implements 
            }

            final float normScale = MagnificationScaleProvider.constrainScale(scale);

            setMagnificationFrameOffsetRatioByWindowPosition(windowPosition);

            if (mWindowMagnificationManager.enableWindowMagnificationInternal(mDisplayId, normScale,

                    centerX, centerY, mMagnificationFrameOffsetRatio.x,

            if (mMagnificationConnectionManager.enableWindowMagnificationInternal(mDisplayId,

                    normScale, centerX, centerY, mMagnificationFrameOffsetRatio.x,

                    mMagnificationFrameOffsetRatio.y, animationCallback)) {

                mScale = normScale;

                mEnabled = true;
@@ -1096,12 +1100,15 @@ public class WindowMagnificationManager implements 
            }

        }



        // TODO(b/312324808): Investigating whether

        //  mMagnificationConnectionManager#disableWindowMagnificationInternal requires a sync lock

        @SuppressWarnings("GuardedBy")

        boolean disableWindowMagnificationInternal(

                @Nullable MagnificationAnimationCallback animationResultCallback) {

            if (!mEnabled) {

                return false;

            }

            if (mWindowMagnificationManager.disableWindowMagnificationInternal(

            if (mMagnificationConnectionManager.disableWindowMagnificationInternal(

                    mDisplayId, animationResultCallback)) {

                mEnabled = false;

                mIdOfLastServiceToControl = INVALID_SERVICE_ID;
@@ -1112,6 +1119,10 @@ public class WindowMagnificationManager implements 
            return false;

        }



        // ErrorProne says the access of mMagnificationConnectionManager#setScaleInternal should

        // be guarded by 'this.mMagnificationConnectionManager.mLock' which is the same one as

        // 'mLock'. Therefore, we'll put @SuppressWarnings here.

        @SuppressWarnings("GuardedBy")

        @GuardedBy("mLock")

        void setScale(float scale) {

            if (!mEnabled) {
@@ -1119,7 +1130,7 @@ public class WindowMagnificationManager implements 
            }

            final float normScale = MagnificationScaleProvider.constrainScale(scale);

            if (Float.compare(mScale, normScale) != 0

                    && mWindowMagnificationManager.setScaleInternal(mDisplayId, scale)) {

                    && mMagnificationConnectionManager.setScaleInternal(mDisplayId, scale)) {

                mScale = normScale;

            }

        }
@@ -1159,8 +1170,8 @@ public class WindowMagnificationManager implements 
        }



        void setTrackingTypingFocusEnabled(boolean trackingTypingFocusEnabled) {

            if (mWindowMagnificationManager.isWindowMagnifierEnabled(mDisplayId)

                    && mWindowMagnificationManager.isImeVisible(mDisplayId)

            if (mMagnificationConnectionManager.isWindowMagnifierEnabled(mDisplayId)

                    && mMagnificationConnectionManager.isImeVisible(mDisplayId)

                    && trackingTypingFocusEnabled) {

                startTrackingTypingFocusRecord();

            }
@@ -1206,7 +1217,7 @@ public class WindowMagnificationManager implements 
                    Slog.d(TAG, "stop and log: session duration = " + duration

                            + ", elapsed = " + elapsed);

                }

                mWindowMagnificationManager.logTrackingTypingFocus(duration);

                mMagnificationConnectionManager.logTrackingTypingFocus(duration);

                mTrackingTypingFocusStartTime = 0;

                mTrackingTypingFocusSumTime = 0;

            }
@@ -1216,9 +1227,14 @@ public class WindowMagnificationManager implements 
            return mEnabled;

        }



        // ErrorProne says the access of mMagnificationConnectionManager#moveWindowMagnifierInternal

        // should be guarded by 'this.mMagnificationConnectionManager.mLock' which is the same one

        // as 'mLock'. Therefore, we'll put @SuppressWarnings here.

        @SuppressWarnings("GuardedBy")

        @GuardedBy("mLock")

        void move(float offsetX, float offsetY) {

            mWindowMagnificationManager.moveWindowMagnifierInternal(mDisplayId, offsetX, offsetY);

            mMagnificationConnectionManager.moveWindowMagnifierInternal(

                    mDisplayId, offsetX, offsetY);

        }



        @GuardedBy("mLock")

services/accessibility/java/com/android/server/accessibility/magnification/MagnificationController.java

+60 −55

File changed.

Preview size limit exceeded, changes collapsed.

services/accessibility/java/com/android/server/accessibility/magnification/MagnificationProcessor.java

+20 −18
Original line number Diff line number Diff line
@@ -84,13 +84,13 @@ public class MagnificationProcessor { 
                    .setCenterX(fullScreenMagnificationController.getCenterX(displayId))

                    .setCenterY(fullScreenMagnificationController.getCenterY(displayId));

        } else if (mode == MAGNIFICATION_MODE_WINDOW) {

            final WindowMagnificationManager windowMagnificationManager =

                    mController.getWindowMagnificationMgr();

            final MagnificationConnectionManager magnificationConnectionManager =

                    mController.getMagnificationConnectionManager();

            builder.setMode(mode)

                    .setActivated(mController.isActivated(displayId, MAGNIFICATION_MODE_WINDOW))

                    .setScale(windowMagnificationManager.getScale(displayId))

                    .setCenterX(windowMagnificationManager.getCenterX(displayId))

                    .setCenterY(windowMagnificationManager.getCenterY(displayId));

                    .setScale(magnificationConnectionManager.getScale(displayId))

                    .setCenterX(magnificationConnectionManager.getCenterX(displayId))

                    .setCenterY(magnificationConnectionManager.getCenterY(displayId));

        } else {

            // For undefined mode, set enabled to false

            builder.setActivated(false);
@@ -135,12 +135,12 @@ public class MagnificationProcessor { 
            }

        } else if (configMode == MAGNIFICATION_MODE_WINDOW) {

            if (configActivated) {

                return mController.getWindowMagnificationMgr().enableWindowMagnification(displayId,

                        config.getScale(), config.getCenterX(), config.getCenterY(),

                return mController.getMagnificationConnectionManager().enableWindowMagnification(

                        displayId, config.getScale(), config.getCenterX(), config.getCenterY(),

                        animate ? STUB_ANIMATION_CALLBACK : null,

                        id);

            } else {

                return mController.getWindowMagnificationMgr()

                return mController.getMagnificationConnectionManager()

                        .disableWindowMagnification(displayId, false);

            }

        }
@@ -256,7 +256,7 @@ public class MagnificationProcessor { 
        if (currentMode == MAGNIFICATION_MODE_FULLSCREEN) {

            getFullscreenMagnificationRegion(displayId, outRegion, canControlMagnification);

        } else if (currentMode == MAGNIFICATION_MODE_WINDOW) {

            mController.getWindowMagnificationMgr().getMagnificationSourceBounds(displayId,

            mController.getMagnificationConnectionManager().getMagnificationSourceBounds(displayId,

                    outRegion);

        }

    }
@@ -297,8 +297,8 @@ public class MagnificationProcessor { 
        if (mode == MAGNIFICATION_MODE_FULLSCREEN) {

            return mController.getFullScreenMagnificationController().reset(displayId, animate);

        } else if (mode == MAGNIFICATION_MODE_WINDOW) {

            return mController.getWindowMagnificationMgr().disableWindowMagnification(displayId,

                    false, animate ? STUB_ANIMATION_CALLBACK : null);

            return mController.getMagnificationConnectionManager().disableWindowMagnification(

                    displayId, false, animate ? STUB_ANIMATION_CALLBACK : null);

        }

        return false;

    }
@@ -325,19 +325,20 @@ public class MagnificationProcessor { 
     */

    public void resetAllIfNeeded(int connectionId) {

        mController.getFullScreenMagnificationController().resetAllIfNeeded(connectionId);

        mController.getWindowMagnificationMgr().resetAllIfNeeded(connectionId);

        mController.getMagnificationConnectionManager().resetAllIfNeeded(connectionId);

    }



    /**

     * {@link FullScreenMagnificationController#isActivated(int)}

     * {@link WindowMagnificationManager#isWindowMagnifierEnabled(int)}

     * {@link MagnificationConnectionManager#isWindowMagnifierEnabled(int)}

     */

    public boolean isMagnifying(int displayId) {

        int mode = getControllingMode(displayId);

        if (mode == MAGNIFICATION_MODE_FULLSCREEN) {

            return mController.getFullScreenMagnificationController().isActivated(displayId);

        } else if (mode == MAGNIFICATION_MODE_WINDOW) {

            return mController.getWindowMagnificationMgr().isWindowMagnifierEnabled(displayId);

            return mController.getMagnificationConnectionManager().isWindowMagnifierEnabled(

                    displayId);

        }

        return false;

    }
@@ -416,22 +417,23 @@ public class MagnificationProcessor { 
        pw.append("    SupportWindowMagnification="

                + mController.supportWindowMagnification()).println();

        pw.append("    WindowMagnificationConnectionState="

                + mController.getWindowMagnificationMgr().getConnectionState()).println();

                + mController.getMagnificationConnectionManager().getConnectionState()).println();

    }



    private int getIdOfLastServiceToMagnify(int mode, int displayId) {

        return (mode == MAGNIFICATION_MODE_FULLSCREEN)

                ? mController.getFullScreenMagnificationController()

                .getIdOfLastServiceToMagnify(displayId)

                : mController.getWindowMagnificationMgr().getIdOfLastServiceToMagnify(

                : mController.getMagnificationConnectionManager().getIdOfLastServiceToMagnify(

                        displayId);

    }



    private void dumpTrackingTypingFocusEnabledState(final PrintWriter pw, int displayId,

            int mode) {

        if (mode == MAGNIFICATION_MODE_WINDOW) {

            pw.append("    TrackingTypingFocusEnabled="  + mController

                            .getWindowMagnificationMgr().isTrackingTypingFocusEnabled(displayId))

            pw.append("    TrackingTypingFocusEnabled="

                            + mController.getMagnificationConnectionManager()

                                .isTrackingTypingFocusEnabled(displayId))

                    .println();

        }

    }