Merge "Allow BrightLineFalsingManager settings to be experimented with via Phenotype." into qt-dev (8d56bbf2) · Commits · e / os / android_frameworks_base

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

+83 −0

Original line number	Diff line number	Diff line
		@@ -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() { }
		}

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

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

+36 −4

Original line number	Diff line number	Diff line
		@@ -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 "