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

Commit a50e7bb2 authored by Dave Mankoff's avatar Dave Mankoff Committed by android-build-merger
Browse files

Merge "Allow BrightLineFalsingManager settings to be experimented with via... 

Merge "Allow BrightLineFalsingManager settings to be experimented with via Phenotype." into qt-r1-dev
am: 1ec1ecb3

Change-Id: I8ff7f9c7f9e9c4d10d5e36285f6ac043de8cca11
parents d3dcd040 1ec1ecb3

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();

        }