bcec82de66
And, use C++ style casts and use float math functions rather than double ones to save memory space. Also, stop using FloatMath and NativeUtils as standard Math methods are faster now. See http://code.google.com/p/android/issues/detail?id=36199 and https://android-review.googlesource.com/40700 multi-project commit with I4259fb5ab8a15ac5760a7f04fc8f4c860529f04a Change-Id: I0b81cff8c91769f7559a59b9528c75a5aabb4211
198 lines
8 KiB
Java
198 lines
8 KiB
Java
/*
|
|
* Copyright (C) 2012 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.inputmethod.keyboard.internal;
|
|
|
|
import android.graphics.Canvas;
|
|
import android.graphics.Paint;
|
|
|
|
import com.android.inputmethod.latin.Constants;
|
|
import com.android.inputmethod.latin.InputPointers;
|
|
import com.android.inputmethod.latin.ResizableIntArray;
|
|
|
|
public class GestureStroke {
|
|
public static final int DEFAULT_CAPACITY = 128;
|
|
|
|
private final int mPointerId;
|
|
private final ResizableIntArray mEventTimes = new ResizableIntArray(DEFAULT_CAPACITY);
|
|
private final ResizableIntArray mXCoordinates = new ResizableIntArray(DEFAULT_CAPACITY);
|
|
private final ResizableIntArray mYCoordinates = new ResizableIntArray(DEFAULT_CAPACITY);
|
|
private float mLength;
|
|
private float mAngle;
|
|
private int mIncrementalRecognitionSize;
|
|
private int mLastIncrementalBatchSize;
|
|
private long mLastPointTime;
|
|
private int mLastPointX;
|
|
private int mLastPointY;
|
|
|
|
private int mMinGestureLength;
|
|
private int mMinGestureLengthWhileInGesture;
|
|
private int mMinGestureSampleLength;
|
|
|
|
// TODO: Move some of these to resource.
|
|
private static final float MIN_GESTURE_LENGTH_RATIO_TO_KEY_WIDTH = 1.0f;
|
|
private static final float MIN_GESTURE_LENGTH_RATIO_TO_KEY_WIDTH_WHILE_IN_GESTURE = 0.5f;
|
|
private static final int MIN_GESTURE_DURATION = 150; // msec
|
|
private static final int MIN_GESTURE_DURATION_WHILE_IN_GESTURE = 75; // msec
|
|
private static final float MIN_GESTURE_SAMPLING_RATIO_TO_KEY_HEIGHT = 1.0f / 6.0f;
|
|
private static final float GESTURE_RECOG_SPEED_THRESHOLD = 0.4f; // dip/msec
|
|
private static final float GESTURE_RECOG_CURVATURE_THRESHOLD = (float)(Math.PI / 4.0f);
|
|
|
|
private static final float DOUBLE_PI = (float)(2.0f * Math.PI);
|
|
|
|
// Fade based on number of gesture samples, see MIN_GESTURE_SAMPLING_RATIO_TO_KEY_HEIGHT
|
|
private static final int DRAWING_GESTURE_FADE_START = 10;
|
|
private static final int DRAWING_GESTURE_FADE_RATE = 6;
|
|
|
|
public GestureStroke(int pointerId) {
|
|
mPointerId = pointerId;
|
|
reset();
|
|
}
|
|
|
|
public void setGestureSampleLength(final int keyWidth, final int keyHeight) {
|
|
// TODO: Find an appropriate base metric for these length. Maybe diagonal length of the key?
|
|
mMinGestureLength = (int)(keyWidth * MIN_GESTURE_LENGTH_RATIO_TO_KEY_WIDTH);
|
|
mMinGestureLengthWhileInGesture = (int)(
|
|
keyWidth * MIN_GESTURE_LENGTH_RATIO_TO_KEY_WIDTH_WHILE_IN_GESTURE);
|
|
mMinGestureSampleLength = (int)(keyHeight * MIN_GESTURE_SAMPLING_RATIO_TO_KEY_HEIGHT);
|
|
}
|
|
|
|
public boolean isStartOfAGesture(final int downDuration, final boolean wasInGesture) {
|
|
// The tolerance of the time duration and the stroke length to detect the start of a
|
|
// gesture stroke should be eased when the previous input was a gesture input.
|
|
if (wasInGesture) {
|
|
return downDuration > MIN_GESTURE_DURATION_WHILE_IN_GESTURE
|
|
&& mLength > mMinGestureLengthWhileInGesture;
|
|
}
|
|
return downDuration > MIN_GESTURE_DURATION && mLength > mMinGestureLength;
|
|
}
|
|
|
|
public void reset() {
|
|
mLength = 0;
|
|
mAngle = 0;
|
|
mIncrementalRecognitionSize = 0;
|
|
mLastIncrementalBatchSize = 0;
|
|
mLastPointTime = 0;
|
|
mEventTimes.setLength(0);
|
|
mXCoordinates.setLength(0);
|
|
mYCoordinates.setLength(0);
|
|
}
|
|
|
|
private void updateLastPoint(final int x, final int y, final int time) {
|
|
mLastPointTime = time;
|
|
mLastPointX = x;
|
|
mLastPointY = y;
|
|
}
|
|
|
|
public void addPoint(final int x, final int y, final int time, final boolean isHistorical) {
|
|
final int size = mEventTimes.getLength();
|
|
if (size == 0) {
|
|
mEventTimes.add(time);
|
|
mXCoordinates.add(x);
|
|
mYCoordinates.add(y);
|
|
if (!isHistorical) {
|
|
updateLastPoint(x, y, time);
|
|
}
|
|
return;
|
|
}
|
|
|
|
final int lastX = mXCoordinates.get(size - 1);
|
|
final int lastY = mYCoordinates.get(size - 1);
|
|
final float dist = getDistance(lastX, lastY, x, y);
|
|
if (dist > mMinGestureSampleLength) {
|
|
mEventTimes.add(time);
|
|
mXCoordinates.add(x);
|
|
mYCoordinates.add(y);
|
|
mLength += dist;
|
|
final float angle = getAngle(lastX, lastY, x, y);
|
|
if (size > 1) {
|
|
final float curvature = getAngleDiff(angle, mAngle);
|
|
if (curvature > GESTURE_RECOG_CURVATURE_THRESHOLD) {
|
|
if (size > mIncrementalRecognitionSize) {
|
|
mIncrementalRecognitionSize = size;
|
|
}
|
|
}
|
|
}
|
|
mAngle = angle;
|
|
}
|
|
|
|
if (!isHistorical) {
|
|
final int duration = (int)(time - mLastPointTime);
|
|
if (mLastPointTime != 0 && duration > 0) {
|
|
final float speed = getDistance(mLastPointX, mLastPointY, x, y) / duration;
|
|
if (speed < GESTURE_RECOG_SPEED_THRESHOLD) {
|
|
mIncrementalRecognitionSize = size;
|
|
}
|
|
}
|
|
updateLastPoint(x, y, time);
|
|
}
|
|
}
|
|
|
|
public void appendAllBatchPoints(final InputPointers out) {
|
|
appendBatchPoints(out, mEventTimes.getLength());
|
|
}
|
|
|
|
public void appendIncrementalBatchPoints(final InputPointers out) {
|
|
appendBatchPoints(out, mIncrementalRecognitionSize);
|
|
}
|
|
|
|
private void appendBatchPoints(final InputPointers out, final int size) {
|
|
out.append(mPointerId, mEventTimes, mXCoordinates, mYCoordinates,
|
|
mLastIncrementalBatchSize, size - mLastIncrementalBatchSize);
|
|
mLastIncrementalBatchSize = size;
|
|
}
|
|
|
|
private static float getDistance(final int p1x, final int p1y,
|
|
final int p2x, final int p2y) {
|
|
final float dx = p1x - p2x;
|
|
final float dy = p1y - p2y;
|
|
// Note that, in recent versions of Android, FloatMath is actually slower than
|
|
// java.lang.Math due to the way the JIT optimizes java.lang.Math.
|
|
return (float)Math.sqrt(dx * dx + dy * dy);
|
|
}
|
|
|
|
private static float getAngle(final int p1x, final int p1y, final int p2x, final int p2y) {
|
|
final int dx = p1x - p2x;
|
|
final int dy = p1y - p2y;
|
|
if (dx == 0 && dy == 0) return 0;
|
|
return (float)Math.atan2(dy, dx);
|
|
}
|
|
|
|
private static float getAngleDiff(final float a1, final float a2) {
|
|
final float diff = Math.abs(a1 - a2);
|
|
if (diff > Math.PI) {
|
|
return DOUBLE_PI - diff;
|
|
}
|
|
return diff;
|
|
}
|
|
|
|
public void drawGestureTrail(Canvas canvas, Paint paint, int lastX, int lastY) {
|
|
// TODO: These paint parameter interpolation should be tunable, possibly introduce an object
|
|
// that implements an interface such as Paint getPaint(int step, int strokePoints)
|
|
final int size = mXCoordinates.getLength();
|
|
int[] xCoords = mXCoordinates.getPrimitiveArray();
|
|
int[] yCoords = mYCoordinates.getPrimitiveArray();
|
|
int alpha = Constants.Color.ALPHA_OPAQUE;
|
|
for (int i = size - 1; i > 0 && alpha > 0; i--) {
|
|
paint.setAlpha(alpha);
|
|
if (size - i > DRAWING_GESTURE_FADE_START) {
|
|
alpha -= DRAWING_GESTURE_FADE_RATE;
|
|
}
|
|
canvas.drawLine(xCoords[i - 1], yCoords[i - 1], xCoords[i], yCoords[i], paint);
|
|
if (i == size - 1) {
|
|
canvas.drawLine(lastX, lastY, xCoords[i], yCoords[i], paint);
|
|
}
|
|
}
|
|
}
|
|
}
|