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

Commit 8bd32b52 authored by Roy Chou's avatar Roy Chou Committed by Android (Google) Code Review
Browse files

Merge "chore(#Magnification): add new field in metric MagnificationUsageReported" into udc-dev

parents fcdac40e 47e39ef9
Loading
Loading
Loading
Loading
+8 −2
Original line number Original line Diff line number Diff line
@@ -149,11 +149,13 @@ public final class AccessibilityStatsLogUtils {
     *
     *
     * @param mode The activated magnification mode.
     * @param mode The activated magnification mode.
     * @param duration The duration in milliseconds during the magnification is activated.
     * @param duration The duration in milliseconds during the magnification is activated.
     * @param scale The last magnification scale for the activation
     */
     */
    public static void logMagnificationUsageState(int mode, long duration) {
    public static void logMagnificationUsageState(int mode, long duration, float scale) {
        FrameworkStatsLog.write(FrameworkStatsLog.MAGNIFICATION_USAGE_REPORTED,
        FrameworkStatsLog.write(FrameworkStatsLog.MAGNIFICATION_USAGE_REPORTED,
                convertToLoggingMagnificationMode(mode),
                convertToLoggingMagnificationMode(mode),
                duration);
                duration,
                convertToLoggingMagnificationScale(scale));
    }
    }


    /**
    /**
@@ -254,4 +256,8 @@ public final class AccessibilityStatsLogUtils {
                return MAGNIFICATION_USAGE_REPORTED__ACTIVATED_MODE__MAGNIFICATION_UNKNOWN_MODE;
                return MAGNIFICATION_USAGE_REPORTED__ACTIVATED_MODE__MAGNIFICATION_UNKNOWN_MODE;
        }
        }
    }
    }

    private static int convertToLoggingMagnificationScale(float scale) {
        return (int) (scale * 100);
    }
}
}
+4 −0
Original line number Original line Diff line number Diff line
@@ -1072,6 +1072,10 @@ public class FullScreenMagnificationController implements
        }
        }
    }
    }


    protected float getLastActivatedScale(int displayId) {
        return getScale(displayId);
    }

    /**
    /**
     * Returns the X offset of the magnification viewport. If an animation
     * Returns the X offset of the magnification viewport. If an animation
     * is in progress, this reflects the end state of the animation.
     * is in progress, this reflects the end state of the animation.
+10 −4
Original line number Original line Diff line number Diff line
@@ -470,12 +470,14 @@ public class MagnificationController implements WindowMagnificationManager.Callb
            disableFullScreenMagnificationIfNeeded(displayId);
            disableFullScreenMagnificationIfNeeded(displayId);
        } else {
        } else {
            long duration;
            long duration;
            float scale;
            synchronized (mLock) {
            synchronized (mLock) {
                setCurrentMagnificationModeAndSwitchDelegate(displayId,
                setCurrentMagnificationModeAndSwitchDelegate(displayId,
                        ACCESSIBILITY_MAGNIFICATION_MODE_NONE);
                        ACCESSIBILITY_MAGNIFICATION_MODE_NONE);
                duration = SystemClock.uptimeMillis() - mWindowModeEnabledTimeArray.get(displayId);
                duration = SystemClock.uptimeMillis() - mWindowModeEnabledTimeArray.get(displayId);
                scale = mWindowMagnificationMgr.getLastActivatedScale(displayId);
            }
            }
            logMagnificationUsageState(ACCESSIBILITY_MAGNIFICATION_MODE_WINDOW, duration);
            logMagnificationUsageState(ACCESSIBILITY_MAGNIFICATION_MODE_WINDOW, duration, scale);
        }
        }
        updateMagnificationUIControls(displayId, ACCESSIBILITY_MAGNIFICATION_MODE_WINDOW);
        updateMagnificationUIControls(displayId, ACCESSIBILITY_MAGNIFICATION_MODE_WINDOW);
    }
    }
@@ -567,13 +569,16 @@ public class MagnificationController implements WindowMagnificationManager.Callb
            disableWindowMagnificationIfNeeded(displayId);
            disableWindowMagnificationIfNeeded(displayId);
        } else {
        } else {
            long duration;
            long duration;
            float scale;
            synchronized (mLock) {
            synchronized (mLock) {
                setCurrentMagnificationModeAndSwitchDelegate(displayId,
                setCurrentMagnificationModeAndSwitchDelegate(displayId,
                        ACCESSIBILITY_MAGNIFICATION_MODE_NONE);
                        ACCESSIBILITY_MAGNIFICATION_MODE_NONE);
                duration = SystemClock.uptimeMillis()
                duration = SystemClock.uptimeMillis()
                        - mFullScreenModeEnabledTimeArray.get(displayId);
                        - mFullScreenModeEnabledTimeArray.get(displayId);
                scale = mFullScreenMagnificationController.getLastActivatedScale(displayId);
            }
            }
            logMagnificationUsageState(ACCESSIBILITY_MAGNIFICATION_MODE_FULLSCREEN, duration);
            logMagnificationUsageState(
                    ACCESSIBILITY_MAGNIFICATION_MODE_FULLSCREEN, duration, scale);
        }
        }
        updateMagnificationUIControls(displayId, ACCESSIBILITY_MAGNIFICATION_MODE_FULLSCREEN);
        updateMagnificationUIControls(displayId, ACCESSIBILITY_MAGNIFICATION_MODE_FULLSCREEN);
    }
    }
@@ -612,10 +617,11 @@ public class MagnificationController implements WindowMagnificationManager.Callb
     *
     *
     * @param mode The activated magnification mode.
     * @param mode The activated magnification mode.
     * @param duration The duration in milliseconds during the magnification is activated.
     * @param duration The duration in milliseconds during the magnification is activated.
     * @param scale The last magnification scale for the activation
     */
     */
    @VisibleForTesting
    @VisibleForTesting
    public void logMagnificationUsageState(int mode, long duration) {
    public void logMagnificationUsageState(int mode, long duration, float scale) {
        AccessibilityStatsLogUtils.logMagnificationUsageState(mode, duration);
        AccessibilityStatsLogUtils.logMagnificationUsageState(mode, duration, scale);
    }
    }


    /**
    /**
+15 −0
Original line number Original line Diff line number Diff line
@@ -142,6 +142,8 @@ public class WindowMagnificationManager implements
    private boolean mMagnificationFollowTypingEnabled = true;
    private boolean mMagnificationFollowTypingEnabled = true;
    @GuardedBy("mLock")
    @GuardedBy("mLock")
    private final SparseBooleanArray mIsImeVisibleArray = new SparseBooleanArray();
    private final SparseBooleanArray mIsImeVisibleArray = new SparseBooleanArray();
    @GuardedBy("mLock")
    private final SparseArray<Float> mLastActivatedScale = new SparseArray<>();


    private boolean mReceiverRegistered = false;
    private boolean mReceiverRegistered = false;
    @VisibleForTesting
    @VisibleForTesting
@@ -528,6 +530,7 @@ public class WindowMagnificationManager implements
                return;
                return;
            }
            }
            magnifier.setScale(scale);
            magnifier.setScale(scale);
            mLastActivatedScale.put(displayId, scale);
        }
        }
    }
    }


@@ -615,6 +618,9 @@ public class WindowMagnificationManager implements
            previousEnabled = magnifier.mEnabled;
            previousEnabled = magnifier.mEnabled;
            enabled = magnifier.enableWindowMagnificationInternal(scale, centerX, centerY,
            enabled = magnifier.enableWindowMagnificationInternal(scale, centerX, centerY,
                    animationCallback, windowPosition, id);
                    animationCallback, windowPosition, id);
            if (enabled) {
                mLastActivatedScale.put(displayId, getScale(displayId));
            }
        }
        }


        if (enabled) {
        if (enabled) {
@@ -752,6 +758,15 @@ public class WindowMagnificationManager implements
        }
        }
    }
    }


    protected float getLastActivatedScale(int displayId) {
        synchronized (mLock) {
            if (!mLastActivatedScale.contains(displayId)) {
                return -1.0f;
            }
            return mLastActivatedScale.get(displayId);
        }
    }

    /**
    /**
     * Moves window magnification on the specified display with the specified offset.
     * Moves window magnification on the specified display with the specified offset.
     *
     *
+42 −33
Original line number Original line Diff line number Diff line
@@ -208,8 +208,8 @@ public class MagnificationControllerTest {
        mMockConnection = new MockWindowMagnificationConnection(true);
        mMockConnection = new MockWindowMagnificationConnection(true);
        mWindowMagnificationManager.setConnection(mMockConnection.getConnection());
        mWindowMagnificationManager.setConnection(mMockConnection.getConnection());


        mMagnificationController = new MagnificationController(mService, globalLock, mContext,
        mMagnificationController = spy(new MagnificationController(mService, globalLock, mContext,
                mScreenMagnificationController, mWindowMagnificationManager, mScaleProvider);
                mScreenMagnificationController, mWindowMagnificationManager, mScaleProvider));
        mMagnificationController.setMagnificationCapabilities(
        mMagnificationController.setMagnificationCapabilities(
                Settings.Secure.ACCESSIBILITY_MAGNIFICATION_MODE_ALL);
                Settings.Secure.ACCESSIBILITY_MAGNIFICATION_MODE_ALL);


@@ -774,15 +774,21 @@ public class MagnificationControllerTest {
        verify(mWindowMagnificationManager, times(2)).removeMagnificationButton(eq(TEST_DISPLAY));
        verify(mWindowMagnificationManager, times(2)).removeMagnificationButton(eq(TEST_DISPLAY));
    }
    }


    @Test public void activateWindowMagnification_triggerCallback() throws RemoteException {
        setMagnificationEnabled(MODE_WINDOW);
        verify(mMagnificationController).onWindowMagnificationActivationState(
                eq(TEST_DISPLAY), eq(true));
    }
    @Test
    @Test
    public void onWindowMagnificationActivationState_windowActivated_logWindowDuration() {
    public void deactivateWindowMagnification_windowActivated_triggerCallbackAndLogUsage()
        MagnificationController spyController = spy(mMagnificationController);
            throws RemoteException {
        spyController.onWindowMagnificationActivationState(TEST_DISPLAY, true);
        setMagnificationEnabled(MODE_WINDOW);

        mWindowMagnificationManager.disableWindowMagnification(TEST_DISPLAY, /* clear= */ true);
        spyController.onWindowMagnificationActivationState(TEST_DISPLAY, false);


        verify(spyController).logMagnificationUsageState(
        verify(mMagnificationController).onWindowMagnificationActivationState(
                eq(ACCESSIBILITY_MAGNIFICATION_MODE_WINDOW), anyLong());
                eq(TEST_DISPLAY), eq(false));
        verify(mMagnificationController).logMagnificationUsageState(
                eq(ACCESSIBILITY_MAGNIFICATION_MODE_WINDOW), anyLong(), eq(DEFAULT_SCALE));
    }
    }


    @Test
    @Test
@@ -906,15 +912,22 @@ public class MagnificationControllerTest {
        assertEquals(ACCESSIBILITY_MAGNIFICATION_MODE_FULLSCREEN, lastActivatedMode);
        assertEquals(ACCESSIBILITY_MAGNIFICATION_MODE_FULLSCREEN, lastActivatedMode);
    }
    }


    @Test
    @Test public void activateFullScreenMagnification_triggerCallback() throws RemoteException {
    public void onFullScreenMagnificationActivationState_fullScreenEnabled_logFullScreenDuration() {
        setMagnificationEnabled(MODE_FULLSCREEN);
        MagnificationController spyController = spy(mMagnificationController);
        verify(mMagnificationController).onFullScreenMagnificationActivationState(
        spyController.onFullScreenMagnificationActivationState(TEST_DISPLAY, true);
                eq(TEST_DISPLAY), eq(true));
    }


        spyController.onFullScreenMagnificationActivationState(TEST_DISPLAY, false);
    @Test
    public void deactivateFullScreenMagnification_fullScreenEnabled_triggerCallbackAndLogUsage()
            throws RemoteException {
        setMagnificationEnabled(MODE_FULLSCREEN);
        mScreenMagnificationController.reset(TEST_DISPLAY, /* animate= */ false);


        verify(spyController).logMagnificationUsageState(
        verify(mMagnificationController).onFullScreenMagnificationActivationState(
                eq(ACCESSIBILITY_MAGNIFICATION_MODE_FULLSCREEN), anyLong());
                eq(TEST_DISPLAY), eq(false));
        verify(mMagnificationController).logMagnificationUsageState(
                eq(ACCESSIBILITY_MAGNIFICATION_MODE_FULLSCREEN), anyLong(), eq(DEFAULT_SCALE));
    }
    }


    @Test
    @Test
@@ -1106,48 +1119,44 @@ public class MagnificationControllerTest {


    @Test
    @Test
    public void imeWindowStateShown_windowMagnifying_logWindowMode() {
    public void imeWindowStateShown_windowMagnifying_logWindowMode() {
        MagnificationController spyController = spy(mMagnificationController);
        mMagnificationController.onWindowMagnificationActivationState(TEST_DISPLAY, true);
        spyController.onWindowMagnificationActivationState(TEST_DISPLAY, true);


        spyController.onImeWindowVisibilityChanged(TEST_DISPLAY, true);
        mMagnificationController.onImeWindowVisibilityChanged(TEST_DISPLAY, true);


        verify(spyController).logMagnificationModeWithIme(
        verify(mMagnificationController).logMagnificationModeWithIme(
                eq(ACCESSIBILITY_MAGNIFICATION_MODE_WINDOW));
                eq(ACCESSIBILITY_MAGNIFICATION_MODE_WINDOW));
    }
    }


    @Test
    @Test
    public void imeWindowStateShown_fullScreenMagnifying_logFullScreenMode() {
    public void imeWindowStateShown_fullScreenMagnifying_logFullScreenMode() {
        MagnificationController spyController = spy(mMagnificationController);
        mMagnificationController.onFullScreenMagnificationActivationState(TEST_DISPLAY, true);
        spyController.onFullScreenMagnificationActivationState(TEST_DISPLAY, true);


        spyController.onImeWindowVisibilityChanged(TEST_DISPLAY, true);
        mMagnificationController.onImeWindowVisibilityChanged(TEST_DISPLAY, true);


        verify(spyController).logMagnificationModeWithIme(
        verify(mMagnificationController).logMagnificationModeWithIme(
                eq(ACCESSIBILITY_MAGNIFICATION_MODE_FULLSCREEN));
                eq(ACCESSIBILITY_MAGNIFICATION_MODE_FULLSCREEN));
    }
    }


    @Test
    @Test
    public void imeWindowStateShown_noMagnifying_noLogAnyMode() {
    public void imeWindowStateShown_noMagnifying_noLogAnyMode() {
        MagnificationController spyController = spy(mMagnificationController);
        mMagnificationController.onImeWindowVisibilityChanged(TEST_DISPLAY, true);
        spyController.onImeWindowVisibilityChanged(TEST_DISPLAY, true);


        verify(spyController, never()).logMagnificationModeWithIme(anyInt());
        verify(mMagnificationController, never()).logMagnificationModeWithIme(anyInt());
    }
    }


    @Test
    @Test
    public void imeWindowStateHidden_windowMagnifying_noLogAnyMode() {
    public void imeWindowStateHidden_windowMagnifying_noLogAnyMode() {
        MagnificationController spyController = spy(mMagnificationController);
        mMagnificationController.onFullScreenMagnificationActivationState(
        spyController.onFullScreenMagnificationActivationState(TEST_DISPLAY, true);
                TEST_DISPLAY, true);


        verify(spyController, never()).logMagnificationModeWithIme(anyInt());
        verify(mMagnificationController, never()).logMagnificationModeWithIme(anyInt());
    }
    }


    @Test
    @Test
    public void imeWindowStateHidden_fullScreenMagnifying_noLogAnyMode() {
    public void imeWindowStateHidden_fullScreenMagnifying_noLogAnyMode() {
        MagnificationController spyController = spy(mMagnificationController);
        mMagnificationController.onWindowMagnificationActivationState(TEST_DISPLAY, true);
        spyController.onWindowMagnificationActivationState(TEST_DISPLAY, true);


        verify(spyController, never()).logMagnificationModeWithIme(anyInt());
        verify(mMagnificationController, never()).logMagnificationModeWithIme(anyInt());
    }
    }


    @Test
    @Test