Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge "Allow BrightLineFalsingManager settings to be experimented with via Phenotype." into qt-dev

Browse Source
This commit is contained in:
Dave Mankoff
2019-07-24 19:09:02 +00:00
committed by Android (Google) Code Review
parent 486503c74e e38da07841
commit 8d56bbf2e3
5 changed files with 201 additions and 23 deletions
Download Patch File Download Diff File Expand all files Collapse all files

83
core/java/com/android/internal/config/sysui/SystemUiDeviceConfigFlags.java
View File

@@ -186,6 +186,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() { }
}

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

@@ -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)

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

@@ -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;
}

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

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

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

@@ -16,7 +16,13 @@
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.provider.DeviceConfig;
import android.view.MotionEvent;
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_Y_SECONDARY_DEVIANCE = .3f;
private final float mMaxXPrimaryDeviance;
private final float mMaxYPrimaryDeviance;
private final float mMaxXSecondaryDeviance;
private final float mMaxYSecondaryDeviance;
ZigZagClassifier(FalsingDataProvider 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
@@ -98,11 +130,11 @@ class ZigZagClassifier extends FalsingClassifier {
float maxXDeviance;
float maxYDeviance;
if (actualDx > actualDy) {
maxXDeviance = MAX_X_PRIMARY_DEVIANCE * totalDistanceIn * getXdpi();
maxYDeviance = MAX_Y_SECONDARY_DEVIANCE * totalDistanceIn * getYdpi();
maxXDeviance = mMaxXPrimaryDeviance * totalDistanceIn * getXdpi();
maxYDeviance = mMaxYSecondaryDeviance * totalDistanceIn * getYdpi();
} else {
maxXDeviance = MAX_X_SECONDARY_DEVIANCE * totalDistanceIn * getXdpi();
maxYDeviance = MAX_Y_PRIMARY_DEVIANCE * totalDistanceIn * getYdpi();
maxXDeviance = mMaxXSecondaryDeviance * totalDistanceIn * getXdpi();
maxYDeviance = mMaxYPrimaryDeviance * totalDistanceIn * getYdpi();
}
logDebug("Straightness Deviance: (" + devianceX + "," + devianceY + ") vs "