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

Commit e38da078 authored by Dave Mankoff's avatar Dave Mankoff
Browse files

Allow BrightLineFalsingManager settings to be experimented with via Phenotype. 

This is a CP of http://ag/8687829

Bug: 138308096
Test: atest SystemUITests
Change-Id: I9e2b22b157c45da1606466acdfff3c5de7f182e1
Merged-In: I9fa4d1344bb184dea00f92f8d265667f0be11466
parent 0e680785

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

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

     */

    public static final String BRIGHTLINE_FALSING_MANAGER_ENABLED =

    public static final String BRIGHTLINE_FALSING_MANAGER_ENABLED =

            "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() { }

    private SystemUiDeviceConfigFlags() { }

}
 
}

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

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




package com.android.systemui.classifier.brightline;

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.LEFT_AFFORDANCE;

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

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





import android.provider.DeviceConfig;



/**

/**

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

 * 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 ONE_HUNDRED_EIGHTY_DEG = (float) (Math.PI);

    private static final float THREE_HUNDRED_SIXTY_DEG = (float) (2 * 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) {

    DiagonalClassifier(FalsingDataProvider dataProvider) {

        super(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

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

            return false;

        }

        }





        float minAngle = DIAGONAL - HORIZONTAL_ANGLE_RANGE;

        float minAngle = DIAGONAL - mHorizontalAngleRange;

        float maxAngle = DIAGONAL + HORIZONTAL_ANGLE_RANGE;

        float maxAngle = DIAGONAL + mHorizontalAngleRange;

        if (isVertical()) {

        if (isVertical()) {

            minAngle = DIAGONAL - VERTICAL_ANGLE_RANGE;

            minAngle = DIAGONAL - mVerticalAngleRange;

            maxAngle = DIAGONAL + VERTICAL_ANGLE_RANGE;

            maxAngle = DIAGONAL + mVerticalAngleRange;

        }

        }





        return angleBetween(angle, minAngle, maxAngle)

        return angleBetween(angle, minAngle, maxAngle)

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

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




package com.android.systemui.classifier.brightline;

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.MotionEvent;

import android.view.VelocityTracker;

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 HORIZONTAL_SWIPE_THRESHOLD_DISTANCE_IN = 3;

    private static final float VERTICAL_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 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 mVerticalFlingThresholdPx;

    private final float mHorizontalFlingThresholdPx;

    private final float mHorizontalFlingThresholdPx;

    private final float mVerticalSwipeThresholdPx;

    private final float mVerticalSwipeThresholdPx;

    private final float mHorizontalSwipeThresholdPx;

    private final float mHorizontalSwipeThresholdPx;

    private final float mVelocityToDistanceMultiplier;





    private boolean mDistanceDirty;

    private boolean mDistanceDirty;

    private DistanceVectors mCachedDistance;

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

    DistanceClassifier(FalsingDataProvider dataProvider) {

        super(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

        mHorizontalFlingThresholdPx = Math

                .min(getWidthPixels() * SCREEN_FRACTION_MIN_DISTANCE,

                .min(getWidthPixels() * screenFractionMaxDistance,

                        HORIZONTAL_FLING_THRESHOLD_DISTANCE_IN * getXdpi());

                        horizontalFlingThresholdIn * getXdpi());

        mVerticalFlingThresholdPx = Math

        mVerticalFlingThresholdPx = Math

                .min(getHeightPixels() * SCREEN_FRACTION_MIN_DISTANCE,

                .min(getHeightPixels() * screenFractionMaxDistance,

                        VERTICAL_FLING_THRESHOLD_DISTANCE_IN * getYdpi());

                        verticalFlingThresholdIn * getYdpi());

        mHorizontalSwipeThresholdPx = Math

        mHorizontalSwipeThresholdPx = Math

                .min(getWidthPixels() * SCREEN_FRACTION_MIN_DISTANCE,

                .min(getWidthPixels() * screenFractionMaxDistance,

                        HORIZONTAL_SWIPE_THRESHOLD_DISTANCE_IN * getXdpi());

                        horizontalSwipeThresholdIn * getXdpi());

        mVerticalSwipeThresholdPx = Math

        mVerticalSwipeThresholdPx = Math

                .min(getHeightPixels() * SCREEN_FRACTION_MIN_DISTANCE,

                .min(getHeightPixels() * screenFractionMaxDistance,

                        VERTICAL_SWIPE_THRESHOLD_DISTANCE_IN * getYdpi());

                        verticalSwipeThresholdIn * getYdpi());

        mDistanceDirty = true;

        mDistanceDirty = true;

    }

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

        }





        boolean getPassedFlingThreshold() {

        boolean getPassedFlingThreshold() {

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

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

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

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





            if (isHorizontal()) {

            if (isHorizontal()) {

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

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

                        + this.mVx * VELOCITY_TO_DISTANCE);

                        + this.mVx * mVelocityToDistanceMultiplier);

                logDebug("Threshold: " + mHorizontalFlingThresholdPx);

                logDebug("Threshold: " + mHorizontalFlingThresholdPx);

                return Math.abs(dX) >= mHorizontalFlingThresholdPx;

                return Math.abs(dX) >= mHorizontalFlingThresholdPx;

            }

            }





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

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

                    + this.mVy * VELOCITY_TO_DISTANCE);

                    + this.mVy * mVelocityToDistanceMultiplier);

            logDebug("Threshold: " + mVerticalFlingThresholdPx);

            logDebug("Threshold: " + mVerticalFlingThresholdPx);

            return Math.abs(dY) >= mVerticalFlingThresholdPx;

            return Math.abs(dY) >= mVerticalFlingThresholdPx;

        }

        }

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

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




package com.android.systemui.classifier.brightline;

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 static com.android.systemui.classifier.Classifier.QUICK_SETTINGS;





import android.hardware.Sensor;

import android.hardware.Sensor;

import android.hardware.SensorEvent;

import android.hardware.SensorEvent;

import android.provider.DeviceConfig;

import android.view.MotionEvent;

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

 */

class ProximityClassifier extends FalsingClassifier {

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 DistanceClassifier mDistanceClassifier;

    private final float mPercentCoveredThreshold;





    private boolean mNear;

    private boolean mNear;

    private long mGestureStartTimeNs;

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

            FalsingDataProvider dataProvider) {

        super(dataProvider);

        super(dataProvider);

        this.mDistanceClassifier = distanceClassifier;

        this.mDistanceClassifier = distanceClassifier;



        mPercentCoveredThreshold = DeviceConfig.getFloat(

                DeviceConfig.NAMESPACE_SYSTEMUI,

                BRIGHTLINE_FALSING_PROXIMITY_PERCENT_COVERED_THRESHOLD,

                PERCENT_COVERED_THRESHOLD);

    }

    }





    @Override

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




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

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





        if (mPercentNear > PERCENT_COVERED_THRESHOLD) {

        if (mPercentNear > mPercentCoveredThreshold) {

            return !mDistanceClassifier.isLongSwipe();

            return !mDistanceClassifier.isLongSwipe();

        }

        }

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

+36 −4
Original line number Original line Diff line number Diff line
@@ -16,7 +16,13 @@ 




package com.android.systemui.classifier.brightline;

package com.android.systemui.classifier.brightline;





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

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

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

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



import android.graphics.Point;

import android.graphics.Point;

import android.provider.DeviceConfig;

import android.view.MotionEvent;

import android.view.MotionEvent;





import java.util.ArrayList;

import java.util.ArrayList;
@@ -37,8 +43,34 @@ class ZigZagClassifier extends FalsingClassifier { 
    private static final float MAX_X_SECONDARY_DEVIANCE = .3f;

    private static final float MAX_X_SECONDARY_DEVIANCE = .3f;

    private static final float MAX_Y_SECONDARY_DEVIANCE = .3f;

    private static final float MAX_Y_SECONDARY_DEVIANCE = .3f;





    private final float mMaxXPrimaryDeviance;

    private final float mMaxYPrimaryDeviance;

    private final float mMaxXSecondaryDeviance;

    private final float mMaxYSecondaryDeviance;



    ZigZagClassifier(FalsingDataProvider dataProvider) {

    ZigZagClassifier(FalsingDataProvider dataProvider) {

        super(dataProvider);

        super(dataProvider);



        mMaxXPrimaryDeviance = DeviceConfig.getFloat(

                DeviceConfig.NAMESPACE_SYSTEMUI,

                BRIGHTLINE_FALSING_ZIGZAG_X_PRIMARY_DEVIANCE,

                MAX_X_PRIMARY_DEVIANCE);



        mMaxYPrimaryDeviance = DeviceConfig.getFloat(

                DeviceConfig.NAMESPACE_SYSTEMUI,

                BRIGHTLINE_FALSING_ZIGZAG_Y_PRIMARY_DEVIANCE,

                MAX_Y_PRIMARY_DEVIANCE);



        mMaxXSecondaryDeviance = DeviceConfig.getFloat(

                DeviceConfig.NAMESPACE_SYSTEMUI,

                BRIGHTLINE_FALSING_ZIGZAG_X_SECONDARY_DEVIANCE,

                MAX_X_SECONDARY_DEVIANCE);



        mMaxYSecondaryDeviance = DeviceConfig.getFloat(

                DeviceConfig.NAMESPACE_SYSTEMUI,

                BRIGHTLINE_FALSING_ZIGZAG_Y_SECONDARY_DEVIANCE,

                MAX_Y_SECONDARY_DEVIANCE);



    }

    }





    @Override

    @Override
@@ -98,11 +130,11 @@ class ZigZagClassifier extends FalsingClassifier { 
        float maxXDeviance;

        float maxXDeviance;

        float maxYDeviance;

        float maxYDeviance;

        if (actualDx > actualDy) {

        if (actualDx > actualDy) {

            maxXDeviance = MAX_X_PRIMARY_DEVIANCE * totalDistanceIn * getXdpi();

            maxXDeviance = mMaxXPrimaryDeviance * totalDistanceIn * getXdpi();

            maxYDeviance = MAX_Y_SECONDARY_DEVIANCE * totalDistanceIn * getYdpi();

            maxYDeviance = mMaxYSecondaryDeviance * totalDistanceIn * getYdpi();

        } else {

        } else {

            maxXDeviance = MAX_X_SECONDARY_DEVIANCE * totalDistanceIn * getXdpi();

            maxXDeviance = mMaxXSecondaryDeviance * totalDistanceIn * getXdpi();

            maxYDeviance = MAX_Y_PRIMARY_DEVIANCE * totalDistanceIn * getYdpi();

            maxYDeviance = mMaxYPrimaryDeviance * totalDistanceIn * getYdpi();

        }

        }





        logDebug("Straightness Deviance: (" + devianceX + "," + devianceY + ") vs "

        logDebug("Straightness Deviance: (" + devianceX + "," + devianceY + ") vs "