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

Commit 1b80884e authored by Dave Mankoff's avatar Dave Mankoff
Browse files

Allow BrightLineFalsingManager settings to be experimented with via Phenotype. 

This also ensures that the FalsingManagerProxy cleans up its internal instance
whenever a Phenotype flag changes.

Bug: 71762354
Test: atest SystemUITests
Change-Id: I9fa4d1344bb184dea00f92f8d265667f0be11466
parent b7098f9d

core/java/com/android/internal/config/sysui/SystemUiDeviceConfigFlags.java

+83 −0
Original line number Diff line number Diff line
@@ -191,6 +191,89 @@ public final class SystemUiDeviceConfigFlags { 
     */

    public static final String BRIGHTLINE_FALSING_MANAGER_ENABLED =

            "brightline_falsing_manager_enabled";

    /**

     * (float) Maximum fraction of the screen required to qualify as a real swipe.

     */

    public static final String BRIGHTLINE_FALSING_DISTANCE_SCREEN_FRACTION_MAX_DISTANCE =

            "brightline_falsing_distance_screen_fraction_max_distance";



    /**

     * (float) Multiplier for swipe velocity to convert it to pixels for a fling.

     */

    public static final String BRIGHTLINE_FALSING_DISTANCE_VELOCITY_TO_DISTANCE =

            "brightline_falsing_distance_velcoity_to_distance";



    /**

     * (float) How far, in inches, must a fling travel horizontally to qualify as intentional.

     */

    public static final String BRIGHTLINE_FALSING_DISTANCE_HORIZONTAL_FLING_THRESHOLD_IN =

            "brightline_falsing_distance_horizontal_fling_threshold_in";



    /**

     * (float) Maximum fraction of the screen required to qualify as a real swipe.

     */

    public static final String BRIGHTLINE_FALSING_DISTANCE_VERTICAL_FLING_THRESHOLD_IN =

            "brightline_falsing_distance_vertical_fling_threshold_in";



    /**

     * (float) How far, in inches, must a continuous swipe travel horizontally to be intentional.

     */

    public static final String BRIGHTLINE_FALSING_DISTANCE_HORIZONTAL_SWIPE_THRESHOLD_IN =

            "brightline_falsing_distance_horizontal_swipe_threshold_in";



    /**

     * (float) How far, in inches, must a continuous swipe travel vertically to be intentional.

     */

    public static final String BRIGHTLINE_FALSING_DISTANCE_VERTICAL_SWIPE_THRESHOLD_IN =

            "brightline_falsing_distance_horizontal_swipe_threshold_in";



    /**

     * (float) Percentage of swipe with the proximity sensor covered that triggers a higher

     * swipe distance requirement.

     */

    public static final String BRIGHTLINE_FALSING_PROXIMITY_PERCENT_COVERED_THRESHOLD =

            "brightline_falsing_proximity_percent_covered_threshold";



    /**

     * (float) Angle, in radians, that a swipe can vary from horizontal and sill be intentional.

     */

    public static final String BRIGHTLINE_FALSING_DIAGONAL_HORIZONTAL_ANGLE_RANGE =

            "brightline_falsing_diagonal_horizontal_angle_range";



    /**

     * (float) Angle, in radians, that a swipe can vary from vertical and sill be intentional.

     */

    public static final String BRIGHTLINE_FALSING_DIAGONAL_VERTICAL_ANGLE_RANGE =

            "brightline_falsing_diagonal_horizontal_angle_range";



    /**

     * (float) Distance, in inches, that a swipe is allowed to vary in the horizontal direction for

     * horizontal swipes.

     */

    public static final String BRIGHTLINE_FALSING_ZIGZAG_X_PRIMARY_DEVIANCE =

            "brightline_falsing_zigzag_x_primary_deviance";



    /**

     * (float) Distance, in inches, that a swipe is allowed to vary in the vertical direction for

     * vertical swipes.

     */

    public static final String BRIGHTLINE_FALSING_ZIGZAG_Y_PRIMARY_DEVIANCE =

            "brightline_falsing_zigzag_y_primary_deviance";



    /**

     * (float) Distance, in inches, that a swipe is allowed to vary in the horizontal direction for

     * horizontal swipes.

     */

    public static final String BRIGHTLINE_FALSING_ZIGZAG_X_SECONDARY_DEVIANCE =

            "brightline_falsing_zigzag_x_secondary_deviance";



    /**

     * (float) Distance, in inches, that a swipe is allowed to vary in the vertical direction for

     * vertical swipes.

     */

    public static final String BRIGHTLINE_FALSING_ZIGZAG_Y_SECONDARY_DEVIANCE =

            "brightline_falsing_zigzag_y_secondary_deviance";





    private SystemUiDeviceConfigFlags() { }

}

packages/SystemUI/src/com/android/systemui/classifier/FalsingManagerProxy.java

+4 −0
Original line number Diff line number Diff line
@@ -93,6 +93,10 @@ public class FalsingManagerProxy implements FalsingManager { 
    public void setupFalsingManager(Context context) {

        boolean brightlineEnabled = DeviceConfig.getBoolean(

                DeviceConfig.NAMESPACE_SYSTEMUI, BRIGHTLINE_FALSING_MANAGER_ENABLED, false);



        if (mInternalFalsingManager != null) {

            mInternalFalsingManager.cleanup();

        }

        if (!brightlineEnabled) {

            mInternalFalsingManager = new FalsingManagerImpl(context);

        } else {

packages/SystemUI/src/com/android/systemui/classifier/brightline/DiagonalClassifier.java

+20 −4
Original line number Diff line number Diff line
@@ -16,9 +16,13 @@ 


package com.android.systemui.classifier.brightline;



import static com.android.internal.config.sysui.SystemUiDeviceConfigFlags.BRIGHTLINE_FALSING_DIAGONAL_HORIZONTAL_ANGLE_RANGE;

import static com.android.internal.config.sysui.SystemUiDeviceConfigFlags.BRIGHTLINE_FALSING_DIAGONAL_VERTICAL_ANGLE_RANGE;

import static com.android.systemui.classifier.Classifier.LEFT_AFFORDANCE;

import static com.android.systemui.classifier.Classifier.RIGHT_AFFORDANCE;



import android.provider.DeviceConfig;



/**

 * False on swipes that are too close to 45 degrees.

 *
@@ -35,8 +39,20 @@ class DiagonalClassifier extends FalsingClassifier { 
    private static final float ONE_HUNDRED_EIGHTY_DEG = (float) (Math.PI);

    private static final float THREE_HUNDRED_SIXTY_DEG = (float) (2 * Math.PI);



    private final float mHorizontalAngleRange;

    private final float mVerticalAngleRange;



    DiagonalClassifier(FalsingDataProvider dataProvider) {

        super(dataProvider);



        mHorizontalAngleRange = DeviceConfig.getFloat(

                DeviceConfig.NAMESPACE_SYSTEMUI,

                BRIGHTLINE_FALSING_DIAGONAL_HORIZONTAL_ANGLE_RANGE,

                HORIZONTAL_ANGLE_RANGE);

        mVerticalAngleRange = DeviceConfig.getFloat(

                DeviceConfig.NAMESPACE_SYSTEMUI,

                BRIGHTLINE_FALSING_DIAGONAL_VERTICAL_ANGLE_RANGE,

                VERTICAL_ANGLE_RANGE);

    }



    @Override
@@ -52,11 +68,11 @@ class DiagonalClassifier extends FalsingClassifier { 
            return false;

        }



        float minAngle = DIAGONAL - HORIZONTAL_ANGLE_RANGE;

        float maxAngle = DIAGONAL + HORIZONTAL_ANGLE_RANGE;

        float minAngle = DIAGONAL - mHorizontalAngleRange;

        float maxAngle = DIAGONAL + mHorizontalAngleRange;

        if (isVertical()) {

            minAngle = DIAGONAL - VERTICAL_ANGLE_RANGE;

            maxAngle = DIAGONAL + VERTICAL_ANGLE_RANGE;

            minAngle = DIAGONAL - mVerticalAngleRange;

            maxAngle = DIAGONAL + mVerticalAngleRange;

        }



        return angleBetween(angle, minAngle, maxAngle)

packages/SystemUI/src/com/android/systemui/classifier/brightline/DistanceClassifier.java

+52 −13
Original line number Diff line number Diff line
@@ -16,6 +16,14 @@ 


package com.android.systemui.classifier.brightline;



import static com.android.internal.config.sysui.SystemUiDeviceConfigFlags.BRIGHTLINE_FALSING_DISTANCE_HORIZONTAL_FLING_THRESHOLD_IN;

import static com.android.internal.config.sysui.SystemUiDeviceConfigFlags.BRIGHTLINE_FALSING_DISTANCE_HORIZONTAL_SWIPE_THRESHOLD_IN;

import static com.android.internal.config.sysui.SystemUiDeviceConfigFlags.BRIGHTLINE_FALSING_DISTANCE_SCREEN_FRACTION_MAX_DISTANCE;

import static com.android.internal.config.sysui.SystemUiDeviceConfigFlags.BRIGHTLINE_FALSING_DISTANCE_VELOCITY_TO_DISTANCE;

import static com.android.internal.config.sysui.SystemUiDeviceConfigFlags.BRIGHTLINE_FALSING_DISTANCE_VERTICAL_FLING_THRESHOLD_IN;

import static com.android.internal.config.sysui.SystemUiDeviceConfigFlags.BRIGHTLINE_FALSING_DISTANCE_VERTICAL_SWIPE_THRESHOLD_IN;



import android.provider.DeviceConfig;

import android.view.MotionEvent;

import android.view.VelocityTracker;
@@ -31,12 +39,13 @@ class DistanceClassifier extends FalsingClassifier { 
    private static final float HORIZONTAL_SWIPE_THRESHOLD_DISTANCE_IN = 3;

    private static final float VERTICAL_SWIPE_THRESHOLD_DISTANCE_IN = 3;

    private static final float VELOCITY_TO_DISTANCE = 80f;

    private static final float SCREEN_FRACTION_MIN_DISTANCE = 0.8f;

    private static final float SCREEN_FRACTION_MAX_DISTANCE = 0.8f;



    private final float mVerticalFlingThresholdPx;

    private final float mHorizontalFlingThresholdPx;

    private final float mVerticalSwipeThresholdPx;

    private final float mHorizontalSwipeThresholdPx;

    private final float mVelocityToDistanceMultiplier;



    private boolean mDistanceDirty;

    private DistanceVectors mCachedDistance;
@@ -44,18 +53,48 @@ class DistanceClassifier extends FalsingClassifier { 
    DistanceClassifier(FalsingDataProvider dataProvider) {

        super(dataProvider);



        mVelocityToDistanceMultiplier = DeviceConfig.getFloat(

                DeviceConfig.NAMESPACE_SYSTEMUI,

                BRIGHTLINE_FALSING_DISTANCE_VELOCITY_TO_DISTANCE,

                VELOCITY_TO_DISTANCE);



        float horizontalFlingThresholdIn = DeviceConfig.getFloat(

                DeviceConfig.NAMESPACE_SYSTEMUI,

                BRIGHTLINE_FALSING_DISTANCE_HORIZONTAL_FLING_THRESHOLD_IN,

                HORIZONTAL_FLING_THRESHOLD_DISTANCE_IN);



        float verticalFlingThresholdIn = DeviceConfig.getFloat(

                DeviceConfig.NAMESPACE_SYSTEMUI,

                BRIGHTLINE_FALSING_DISTANCE_VERTICAL_FLING_THRESHOLD_IN,

                VERTICAL_FLING_THRESHOLD_DISTANCE_IN);



        float horizontalSwipeThresholdIn = DeviceConfig.getFloat(

                DeviceConfig.NAMESPACE_SYSTEMUI,

                BRIGHTLINE_FALSING_DISTANCE_HORIZONTAL_SWIPE_THRESHOLD_IN,

                HORIZONTAL_SWIPE_THRESHOLD_DISTANCE_IN);



        float verticalSwipeThresholdIn = DeviceConfig.getFloat(

                DeviceConfig.NAMESPACE_SYSTEMUI,

                BRIGHTLINE_FALSING_DISTANCE_VERTICAL_SWIPE_THRESHOLD_IN,

                VERTICAL_SWIPE_THRESHOLD_DISTANCE_IN);



        float screenFractionMaxDistance = DeviceConfig.getFloat(

                DeviceConfig.NAMESPACE_SYSTEMUI,

                BRIGHTLINE_FALSING_DISTANCE_SCREEN_FRACTION_MAX_DISTANCE,

                SCREEN_FRACTION_MAX_DISTANCE);



        mHorizontalFlingThresholdPx = Math

                .min(getWidthPixels() * SCREEN_FRACTION_MIN_DISTANCE,

                        HORIZONTAL_FLING_THRESHOLD_DISTANCE_IN * getXdpi());

                .min(getWidthPixels() * screenFractionMaxDistance,

                        horizontalFlingThresholdIn * getXdpi());

        mVerticalFlingThresholdPx = Math

                .min(getHeightPixels() * SCREEN_FRACTION_MIN_DISTANCE,

                        VERTICAL_FLING_THRESHOLD_DISTANCE_IN * getYdpi());

                .min(getHeightPixels() * screenFractionMaxDistance,

                        verticalFlingThresholdIn * getYdpi());

        mHorizontalSwipeThresholdPx = Math

                .min(getWidthPixels() * SCREEN_FRACTION_MIN_DISTANCE,

                        HORIZONTAL_SWIPE_THRESHOLD_DISTANCE_IN * getXdpi());

                .min(getWidthPixels() * screenFractionMaxDistance,

                        horizontalSwipeThresholdIn * getXdpi());

        mVerticalSwipeThresholdPx = Math

                .min(getHeightPixels() * SCREEN_FRACTION_MIN_DISTANCE,

                        VERTICAL_SWIPE_THRESHOLD_DISTANCE_IN * getYdpi());

                .min(getHeightPixels() * screenFractionMaxDistance,

                        verticalSwipeThresholdIn * getYdpi());

        mDistanceDirty = true;

    }
@@ -139,18 +178,18 @@ class DistanceClassifier extends FalsingClassifier { 
        }



        boolean getPassedFlingThreshold() {

            float dX = this.mDx + this.mVx * VELOCITY_TO_DISTANCE;

            float dY = this.mDy + this.mVy * VELOCITY_TO_DISTANCE;

            float dX = this.mDx + this.mVx * mVelocityToDistanceMultiplier;

            float dY = this.mDy + this.mVy * mVelocityToDistanceMultiplier;



            if (isHorizontal()) {

                logDebug("Horizontal swipe and fling distance: " + this.mDx + ", "

                        + this.mVx * VELOCITY_TO_DISTANCE);

                        + this.mVx * mVelocityToDistanceMultiplier);

                logDebug("Threshold: " + mHorizontalFlingThresholdPx);

                return Math.abs(dX) >= mHorizontalFlingThresholdPx;

            }



            logDebug("Vertical swipe and fling distance: " + this.mDy + ", "

                    + this.mVy * VELOCITY_TO_DISTANCE);

                    + this.mVy * mVelocityToDistanceMultiplier);

            logDebug("Threshold: " + mVerticalFlingThresholdPx);

            return Math.abs(dY) >= mVerticalFlingThresholdPx;

        }

packages/SystemUI/src/com/android/systemui/classifier/brightline/ProximityClassifier.java

+10 −2
Original line number Diff line number Diff line
@@ -16,10 +16,12 @@ 


package com.android.systemui.classifier.brightline;



import static com.android.internal.config.sysui.SystemUiDeviceConfigFlags.BRIGHTLINE_FALSING_PROXIMITY_PERCENT_COVERED_THRESHOLD;

import static com.android.systemui.classifier.Classifier.QUICK_SETTINGS;



import android.hardware.Sensor;

import android.hardware.SensorEvent;

import android.provider.DeviceConfig;

import android.view.MotionEvent;
@@ -31,8 +33,9 @@ import android.view.MotionEvent; 
 */

class ProximityClassifier extends FalsingClassifier {



    private static final double PERCENT_COVERED_THRESHOLD = 0.1;

    private static final float PERCENT_COVERED_THRESHOLD = 0.1f;

    private final DistanceClassifier mDistanceClassifier;

    private final float mPercentCoveredThreshold;



    private boolean mNear;

    private long mGestureStartTimeNs;
@@ -44,6 +47,11 @@ class ProximityClassifier extends FalsingClassifier { 
            FalsingDataProvider dataProvider) {

        super(dataProvider);

        this.mDistanceClassifier = distanceClassifier;



        mPercentCoveredThreshold = DeviceConfig.getFloat(

                DeviceConfig.NAMESPACE_SYSTEMUI,

                BRIGHTLINE_FALSING_PROXIMITY_PERCENT_COVERED_THRESHOLD,

                PERCENT_COVERED_THRESHOLD);

    }



    @Override
@@ -107,7 +115,7 @@ class ProximityClassifier extends FalsingClassifier { 


        logInfo("Percent of gesture in proximity: " + mPercentNear);



        if (mPercentNear > PERCENT_COVERED_THRESHOLD) {

        if (mPercentNear > mPercentCoveredThreshold) {

            return !mDistanceClassifier.isLongSwipe();

        }