Merge "Remove old falsing implementation." (d9b80f23) · Commits · e / os / android_frameworks_base

packages/SystemUI/plugin/src/com/android/systemui/plugins/FalsingManager.java

+3 −1

Original line number	Diff line number	Diff line
		@@ -21,6 +21,7 @@ import android.view.MotionEvent;

		import com.android.systemui.plugins.annotations.ProvidesInterface;

		import java.io.FileDescriptor;
		import java.io.PrintWriter;

		/**
		@@ -139,7 +140,8 @@ public interface FalsingManager {

		void onTouchEvent(MotionEvent ev, int width, int height);

		void dump(PrintWriter pw);
		/** From com.android.systemui.Dumpable. */
		void dump(FileDescriptor fd, PrintWriter pw, String[] args);

		void cleanup();
		}

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

deleted100644 → 0

+0 −99

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2015 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License
		*/

		package com.android.systemui.classifier;

		import android.view.MotionEvent;

		import java.util.HashMap;

		/**
		* A classifier which looks at the speed and distance between successive points of a Stroke.
		* It looks at two consecutive speeds between two points and calculates the ratio between them.
		* The final result is the maximum of these values. It does the same for distances. If some speed
		* or distance is equal to zero then the ratio between this and the next part is not calculated. To
		* the duration of each part there is added one nanosecond so that it is always possible to
		* calculate the speed of a part.
		*/
		public class AccelerationClassifier extends StrokeClassifier {
		private final HashMap<Stroke, Data> mStrokeMap = new HashMap<>();

		public AccelerationClassifier(ClassifierData classifierData) {
		mClassifierData = classifierData;
		}

		@Override
		public String getTag() {
		return "ACC";
		}

		@Override
		public void onTouchEvent(MotionEvent event) {
		int action = event.getActionMasked();

		if (action == MotionEvent.ACTION_DOWN) {
		mStrokeMap.clear();
		}

		for (int i = 0; i < event.getPointerCount(); i++) {
		Stroke stroke = mClassifierData.getStroke(event.getPointerId(i));
		Point point = stroke.getPoints().get(stroke.getPoints().size() - 1);
		if (mStrokeMap.get(stroke) == null) {
		mStrokeMap.put(stroke, new Data(point));
		} else {
		mStrokeMap.get(stroke).addPoint(point);
		}
		}
		}

		@Override
		public float getFalseTouchEvaluation(int type, Stroke stroke) {
		Data data = mStrokeMap.get(stroke);
		return 2 * SpeedRatioEvaluator.evaluate(data.maxSpeedRatio);
		}

		private static class Data {

		static final float MILLIS_TO_NANOS = 1e6f;

		Point previousPoint;
		float previousSpeed = 0;
		float maxSpeedRatio = 0;

		public Data(Point point) {
		previousPoint = point;
		}

		public void addPoint(Point point) {
		float distance = previousPoint.dist(point);
		float duration = (float) (point.timeOffsetNano - previousPoint.timeOffsetNano + 1);
		float speed = distance / duration;

		if (duration > 20 * MILLIS_TO_NANOS \|\| duration < 5 * MILLIS_TO_NANOS) {
		// reject this segment and ensure we won't use data about it in the next round.
		previousSpeed = 0;
		previousPoint = point;
		return;
		}
		if (previousSpeed != 0.0f) {
		maxSpeedRatio = Math.max(maxSpeedRatio, speed / previousSpeed);
		}

		previousSpeed = speed;
		previousPoint = point;
		}
		}
		}
		No newline at end of file

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

deleted100644 → 0

+0 −207

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2015 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License
		*/

		package com.android.systemui.classifier;

		import android.os.Build;
		import android.os.SystemProperties;
		import android.view.MotionEvent;

		import java.util.ArrayList;
		import java.util.HashMap;
		import java.util.List;

		/**
		* A classifier which calculates the variance of differences between successive angles in a stroke.
		* For each stroke it keeps its last three points. If some successive points are the same, it
		* ignores the repetitions. If a new point is added, the classifier calculates the angle between
		* the last three points. After that, it calculates the difference between this angle and the
		* previously calculated angle. Then it calculates the variance of the differences from a stroke.
		* To the differences there is artificially added value 0.0 and the difference between the first
		* angle and PI (angles are in radians). It helps with strokes which have few points and punishes
		* more strokes which are not smooth.
		*
		* This classifier also tries to split the stroke into two parts in the place in which the biggest
		* angle is. It calculates the angle variance of the two parts and sums them up. The reason the
		* classifier is doing this, is because some human swipes at the beginning go for a moment in one
		* direction and then they rapidly change direction for the rest of the stroke (like a tick). The
		* final result is the minimum of angle variance of the whole stroke and the sum of angle variances
		* of the two parts split up. The classifier tries the tick option only if the first part is
		* shorter than the second part.
		*
		* Additionally, the classifier classifies the angles as left angles (those angles which value is
		* in [0.0, PI - ANGLE_DEVIATION) interval), straight angles
		* ([PI - ANGLE_DEVIATION, PI + ANGLE_DEVIATION] interval) and right angles
		* ((PI + ANGLE_DEVIATION, 2 * PI) interval) and then calculates the percentage of angles which are
		* in the same direction (straight angles can be left angels or right angles)
		*/
		public class AnglesClassifier extends StrokeClassifier {
		private HashMap<Stroke, Data> mStrokeMap = new HashMap<>();

		public static final boolean VERBOSE = SystemProperties.getBoolean("debug.falsing_log.ang",
		Build.IS_DEBUGGABLE);

		private static String TAG = "ANG";

		public AnglesClassifier(ClassifierData classifierData) {
		mClassifierData = classifierData;
		}

		@Override
		public String getTag() {
		return TAG;
		}

		@Override
		public void onTouchEvent(MotionEvent event) {
		int action = event.getActionMasked();

		if (action == MotionEvent.ACTION_DOWN) {
		mStrokeMap.clear();
		}

		for (int i = 0; i < event.getPointerCount(); i++) {
		Stroke stroke = mClassifierData.getStroke(event.getPointerId(i));

		if (mStrokeMap.get(stroke) == null) {
		mStrokeMap.put(stroke, new Data());
		}
		mStrokeMap.get(stroke).addPoint(stroke.getPoints().get(stroke.getPoints().size() - 1));
		}
		}

		@Override
		public float getFalseTouchEvaluation(int type, Stroke stroke) {
		Data data = mStrokeMap.get(stroke);
		return AnglesVarianceEvaluator.evaluate(data.getAnglesVariance(), type)
		+ AnglesPercentageEvaluator.evaluate(data.getAnglesPercentage(), type);
		}

		private static class Data {
		private final float ANGLE_DEVIATION = (float) Math.PI / 20.0f;

		private List<Point> mLastThreePoints = new ArrayList<>();
		private float mFirstAngleVariance;
		private float mPreviousAngle;
		private float mBiggestAngle;
		private float mSumSquares;
		private float mSecondSumSquares;
		private float mSum;
		private float mSecondSum;
		private float mCount;
		private float mSecondCount;
		private float mFirstLength;
		private float mLength;
		private float mAnglesCount;
		private float mLeftAngles;
		private float mRightAngles;
		private float mStraightAngles;

		public Data() {
		mFirstAngleVariance = 0.0f;
		mPreviousAngle = (float) Math.PI;
		mBiggestAngle = 0.0f;
		mSumSquares = mSecondSumSquares = 0.0f;
		mSum = mSecondSum = 0.0f;
		mCount = mSecondCount = 1.0f;
		mLength = mFirstLength = 0.0f;
		mAnglesCount = mLeftAngles = mRightAngles = mStraightAngles = 0.0f;
		}

		public void addPoint(Point point) {
		// Checking if the added point is different than the previously added point
		// Repetitions are being ignored so that proper angles are calculated.
		if (mLastThreePoints.isEmpty()
		\|\| !mLastThreePoints.get(mLastThreePoints.size() - 1).equals(point)) {
		if (!mLastThreePoints.isEmpty()) {
		mLength += mLastThreePoints.get(mLastThreePoints.size() - 1).dist(point);
		}
		mLastThreePoints.add(point);
		if (mLastThreePoints.size() == 4) {
		mLastThreePoints.remove(0);

		float angle = mLastThreePoints.get(1).getAngle(mLastThreePoints.get(0),
		mLastThreePoints.get(2));

		mAnglesCount++;
		if (angle < Math.PI - ANGLE_DEVIATION) {
		mLeftAngles++;
		} else if (angle <= Math.PI + ANGLE_DEVIATION) {
		mStraightAngles++;
		} else {
		mRightAngles++;
		}

		float difference = angle - mPreviousAngle;

		// If this is the biggest angle of the stroke so then we save the value of
		// the angle variance so far and start to count the values for the angle
		// variance of the second part.
		if (mBiggestAngle < angle) {
		mBiggestAngle = angle;
		mFirstLength = mLength;
		mFirstAngleVariance = getAnglesVariance(mSumSquares, mSum, mCount);
		mSecondSumSquares = 0.0f;
		mSecondSum = 0.0f;
		mSecondCount = 1.0f;
		} else {
		mSecondSum += difference;
		mSecondSumSquares += difference * difference;
		mSecondCount += 1.0;
		}

		mSum += difference;
		mSumSquares += difference * difference;
		mCount += 1.0;
		mPreviousAngle = angle;
		}
		}
		}

		public float getAnglesVariance(float sumSquares, float sum, float count) {
		return sumSquares / count - (sum / count) * (sum / count);
		}

		public float getAnglesVariance() {
		float anglesVariance = getAnglesVariance(mSumSquares, mSum, mCount);
		if (VERBOSE) {
		FalsingLog.i(TAG, "getAnglesVariance: (first pass) " + anglesVariance);
		FalsingLog.i(TAG, " - mFirstLength=" + mFirstLength);
		FalsingLog.i(TAG, " - mLength=" + mLength);
		}
		if (mFirstLength < mLength / 2f) {
		anglesVariance = Math.min(anglesVariance, mFirstAngleVariance
		+ getAnglesVariance(mSecondSumSquares, mSecondSum, mSecondCount));
		if (VERBOSE) FalsingLog.i(TAG, "getAnglesVariance: (second pass) " + anglesVariance);
		}
		return anglesVariance;
		}

		public float getAnglesPercentage() {
		if (mAnglesCount == 0.0f) {
		if (VERBOSE) FalsingLog.i(TAG, "getAnglesPercentage: count==0, result=1");
		return 1.0f;
		}
		final float result = (Math.max(mLeftAngles, mRightAngles) + mStraightAngles) / mAnglesCount;
		if (VERBOSE) {
		FalsingLog.i(TAG, "getAnglesPercentage: left=" + mLeftAngles + " right="
		+ mRightAngles + " straight=" + mStraightAngles + " count=" + mAnglesCount
		+ " result=" + result);
		}
		return result;
		}
		}
		}

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

deleted100644 → 0

+0 −28

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2015 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License
		*/

		package com.android.systemui.classifier;

		public class AnglesPercentageEvaluator {
		public static float evaluate(float value, int type) {
		final boolean secureUnlock = type == Classifier.BOUNCER_UNLOCK;
		float evaluation = 0.0f;
		if (value < 1.00 && !secureUnlock) evaluation++;
		if (value < 0.90 && !secureUnlock) evaluation++;
		if (value < 0.70) evaluation++;
		return evaluation;
		}
		}

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

deleted100644 → 0

+0 −28

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2015 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License
		*/

		package com.android.systemui.classifier;

		public class AnglesVarianceEvaluator {
		public static float evaluate(float value, int type) {
		float evaluation = 0.0f;
		if (value > 0.20) evaluation++;
		if (value > 0.40) evaluation++;
		if (value > 0.80) evaluation++;
		if (value > 1.50) evaluation++;
		return evaluation;
		}
		}