1024 lines
46 KiB
Java
1024 lines
46 KiB
Java
/*
|
|
* Copyright (C) 2007 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.server;
|
|
|
|
import android.util.Slog;
|
|
import android.view.Display;
|
|
import android.view.MotionEvent;
|
|
import android.view.Surface;
|
|
import android.view.WindowManagerPolicy;
|
|
|
|
import java.io.PrintWriter;
|
|
|
|
public class InputDevice {
|
|
static final boolean DEBUG_POINTERS = false;
|
|
static final boolean DEBUG_HACKS = false;
|
|
|
|
/** Amount that trackball needs to move in order to generate a key event. */
|
|
static final int TRACKBALL_MOVEMENT_THRESHOLD = 6;
|
|
|
|
/** Maximum number of pointers we will track and report. */
|
|
static final int MAX_POINTERS = 10;
|
|
|
|
/**
|
|
* Slop distance for jumpy pointer detection.
|
|
* The vertical range of the screen divided by this is our epsilon value.
|
|
*/
|
|
private static final int JUMPY_EPSILON_DIVISOR = 212;
|
|
|
|
/** Number of jumpy points to drop for touchscreens that need it. */
|
|
private static final int JUMPY_TRANSITION_DROPS = 3;
|
|
private static final int JUMPY_DROP_LIMIT = 3;
|
|
|
|
final int id;
|
|
final int classes;
|
|
final String name;
|
|
final AbsoluteInfo absX;
|
|
final AbsoluteInfo absY;
|
|
final AbsoluteInfo absPressure;
|
|
final AbsoluteInfo absSize;
|
|
|
|
long mKeyDownTime = 0;
|
|
int mMetaKeysState = 0;
|
|
|
|
// For use by KeyInputQueue for keeping track of the current touch
|
|
// data in the old non-multi-touch protocol.
|
|
final int[] curTouchVals = new int[MotionEvent.NUM_SAMPLE_DATA * 2];
|
|
|
|
final MotionState mAbs = new MotionState(0, 0);
|
|
final MotionState mRel = new MotionState(TRACKBALL_MOVEMENT_THRESHOLD,
|
|
TRACKBALL_MOVEMENT_THRESHOLD);
|
|
|
|
static class MotionState {
|
|
int xPrecision;
|
|
int yPrecision;
|
|
float xMoveScale;
|
|
float yMoveScale;
|
|
MotionEvent currentMove = null;
|
|
boolean changed = false;
|
|
boolean everChanged = false;
|
|
long mDownTime = 0;
|
|
|
|
// The currently assigned pointer IDs, corresponding to the last data.
|
|
int[] mPointerIds = new int[MAX_POINTERS];
|
|
|
|
// This is the last generated pointer data, ordered to match
|
|
// mPointerIds.
|
|
boolean mSkipLastPointers;
|
|
int mLastNumPointers = 0;
|
|
final int[] mLastData = new int[MotionEvent.NUM_SAMPLE_DATA * MAX_POINTERS];
|
|
|
|
// This is the next set of pointer data being generated. It is not
|
|
// in any known order, and will be propagated in to mLastData
|
|
// as part of mapping it to the appropriate pointer IDs.
|
|
// Note that we have one extra sample of data here, to help clients
|
|
// avoid doing bounds checking.
|
|
int mNextNumPointers = 0;
|
|
final int[] mNextData = new int[(MotionEvent.NUM_SAMPLE_DATA * MAX_POINTERS)
|
|
+ MotionEvent.NUM_SAMPLE_DATA];
|
|
|
|
// Used to determine whether we dropped bad data, to avoid doing
|
|
// it repeatedly.
|
|
final boolean[] mDroppedBadPoint = new boolean[MAX_POINTERS];
|
|
|
|
// Used to count the number of jumpy points dropped.
|
|
private int mJumpyPointsDropped = 0;
|
|
|
|
// Used to perform averaging of reported coordinates, to smooth
|
|
// the data and filter out transients during a release.
|
|
static final int HISTORY_SIZE = 5;
|
|
int[] mHistoryDataStart = new int[MAX_POINTERS];
|
|
int[] mHistoryDataEnd = new int[MAX_POINTERS];
|
|
final int[] mHistoryData = new int[(MotionEvent.NUM_SAMPLE_DATA * MAX_POINTERS)
|
|
* HISTORY_SIZE];
|
|
final int[] mAveragedData = new int[MotionEvent.NUM_SAMPLE_DATA * MAX_POINTERS];
|
|
|
|
// Temporary data structures for doing the pointer ID mapping.
|
|
final int[] mLast2Next = new int[MAX_POINTERS];
|
|
final int[] mNext2Last = new int[MAX_POINTERS];
|
|
final long[] mNext2LastDistance = new long[MAX_POINTERS];
|
|
|
|
// Temporary data structure for generating the final motion data.
|
|
final float[] mReportData = new float[MotionEvent.NUM_SAMPLE_DATA * MAX_POINTERS];
|
|
|
|
// This is not used here, but can be used by callers for state tracking.
|
|
int mAddingPointerOffset = 0;
|
|
final boolean[] mDown = new boolean[MAX_POINTERS];
|
|
|
|
void dumpIntArray(PrintWriter pw, int[] array) {
|
|
pw.print("[");
|
|
for (int i=0; i<array.length; i++) {
|
|
if (i > 0) pw.print(", ");
|
|
pw.print(array[i]);
|
|
}
|
|
pw.print("]");
|
|
}
|
|
|
|
void dumpBooleanArray(PrintWriter pw, boolean[] array) {
|
|
pw.print("[");
|
|
for (int i=0; i<array.length; i++) {
|
|
if (i > 0) pw.print(", ");
|
|
pw.print(array[i] ? "true" : "false");
|
|
}
|
|
pw.print("]");
|
|
}
|
|
|
|
void dump(PrintWriter pw, String prefix) {
|
|
pw.print(prefix); pw.print("xPrecision="); pw.print(xPrecision);
|
|
pw.print(" yPrecision="); pw.println(yPrecision);
|
|
pw.print(prefix); pw.print("xMoveScale="); pw.print(xMoveScale);
|
|
pw.print(" yMoveScale="); pw.println(yMoveScale);
|
|
if (currentMove != null) {
|
|
pw.print(prefix); pw.print("currentMove="); pw.println(currentMove);
|
|
}
|
|
if (changed || mDownTime != 0) {
|
|
pw.print(prefix); pw.print("changed="); pw.print(changed);
|
|
pw.print(" mDownTime="); pw.println(mDownTime);
|
|
}
|
|
pw.print(prefix); pw.print("mPointerIds="); dumpIntArray(pw, mPointerIds);
|
|
pw.println("");
|
|
if (mSkipLastPointers || mLastNumPointers != 0) {
|
|
pw.print(prefix); pw.print("mSkipLastPointers="); pw.print(mSkipLastPointers);
|
|
pw.print(" mLastNumPointers="); pw.println(mLastNumPointers);
|
|
pw.print(prefix); pw.print("mLastData="); dumpIntArray(pw, mLastData);
|
|
pw.println("");
|
|
}
|
|
if (mNextNumPointers != 0) {
|
|
pw.print(prefix); pw.print("mNextNumPointers="); pw.println(mNextNumPointers);
|
|
pw.print(prefix); pw.print("mNextData="); dumpIntArray(pw, mNextData);
|
|
pw.println("");
|
|
}
|
|
pw.print(prefix); pw.print("mDroppedBadPoint=");
|
|
dumpBooleanArray(pw, mDroppedBadPoint); pw.println("");
|
|
pw.print(prefix); pw.print("mAddingPointerOffset="); pw.println(mAddingPointerOffset);
|
|
pw.print(prefix); pw.print("mDown=");
|
|
dumpBooleanArray(pw, mDown); pw.println("");
|
|
}
|
|
|
|
MotionState(int mx, int my) {
|
|
xPrecision = mx;
|
|
yPrecision = my;
|
|
xMoveScale = mx != 0 ? (1.0f/mx) : 1.0f;
|
|
yMoveScale = my != 0 ? (1.0f/my) : 1.0f;
|
|
for (int i=0; i<MAX_POINTERS; i++) {
|
|
mPointerIds[i] = i;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Special hack for devices that have bad screen data: if one of the
|
|
* points has moved more than a screen height from the last position,
|
|
* then drop it.
|
|
*/
|
|
void dropBadPoint(InputDevice dev) {
|
|
// We should always have absY, but let's be paranoid.
|
|
if (dev.absY == null) {
|
|
return;
|
|
}
|
|
// Don't do anything if a finger is going down or up. We run
|
|
// here before assigning pointer IDs, so there isn't a good
|
|
// way to do per-finger matching.
|
|
if (mNextNumPointers != mLastNumPointers) {
|
|
return;
|
|
}
|
|
|
|
// We consider a single movement across more than a 7/16 of
|
|
// the long size of the screen to be bad. This was a magic value
|
|
// determined by looking at the maximum distance it is feasible
|
|
// to actually move in one sample.
|
|
final int maxDy = ((dev.absY.maxValue-dev.absY.minValue)*7)/16;
|
|
|
|
// Look through all new points and see if any are farther than
|
|
// acceptable from all previous points.
|
|
for (int i=mNextNumPointers-1; i>=0; i--) {
|
|
final int ioff = i * MotionEvent.NUM_SAMPLE_DATA;
|
|
//final int x = mNextData[ioff + MotionEvent.SAMPLE_X];
|
|
final int y = mNextData[ioff + MotionEvent.SAMPLE_Y];
|
|
if (DEBUG_HACKS) Slog.v("InputDevice", "Looking at next point #" + i + ": y=" + y);
|
|
boolean dropped = false;
|
|
if (!mDroppedBadPoint[i] && mLastNumPointers > 0) {
|
|
dropped = true;
|
|
int closestDy = -1;
|
|
int closestY = -1;
|
|
// We will drop this new point if it is sufficiently
|
|
// far away from -all- last points.
|
|
for (int j=mLastNumPointers-1; j>=0; j--) {
|
|
final int joff = j * MotionEvent.NUM_SAMPLE_DATA;
|
|
//int dx = x - mLastData[joff + MotionEvent.SAMPLE_X];
|
|
int dy = y - mLastData[joff + MotionEvent.SAMPLE_Y];
|
|
//if (dx < 0) dx = -dx;
|
|
if (dy < 0) dy = -dy;
|
|
if (DEBUG_HACKS) Slog.v("InputDevice", "Comparing with last point #" + j
|
|
+ ": y=" + mLastData[joff] + " dy=" + dy);
|
|
if (dy < maxDy) {
|
|
dropped = false;
|
|
break;
|
|
} else if (closestDy < 0 || dy < closestDy) {
|
|
closestDy = dy;
|
|
closestY = mLastData[joff + MotionEvent.SAMPLE_Y];
|
|
}
|
|
}
|
|
if (dropped) {
|
|
dropped = true;
|
|
Slog.i("InputDevice", "Dropping bad point #" + i
|
|
+ ": newY=" + y + " closestDy=" + closestDy
|
|
+ " maxDy=" + maxDy);
|
|
mNextData[ioff + MotionEvent.SAMPLE_Y] = closestY;
|
|
break;
|
|
}
|
|
}
|
|
mDroppedBadPoint[i] = dropped;
|
|
}
|
|
}
|
|
|
|
void dropJumpyPoint(InputDevice dev) {
|
|
// We should always have absY, but let's be paranoid.
|
|
if (dev.absY == null) {
|
|
return;
|
|
}
|
|
final int jumpyEpsilon = dev.absY.range / JUMPY_EPSILON_DIVISOR;
|
|
|
|
final int nextNumPointers = mNextNumPointers;
|
|
final int lastNumPointers = mLastNumPointers;
|
|
final int[] nextData = mNextData;
|
|
final int[] lastData = mLastData;
|
|
|
|
if (nextNumPointers != mLastNumPointers) {
|
|
if (DEBUG_HACKS) {
|
|
Slog.d("InputDevice", "Different pointer count " + lastNumPointers +
|
|
" -> " + nextNumPointers);
|
|
for (int i = 0; i < nextNumPointers; i++) {
|
|
int ioff = i * MotionEvent.NUM_SAMPLE_DATA;
|
|
Slog.d("InputDevice", "Pointer " + i + " (" +
|
|
mNextData[ioff + MotionEvent.SAMPLE_X] + ", " +
|
|
mNextData[ioff + MotionEvent.SAMPLE_Y] + ")");
|
|
}
|
|
}
|
|
|
|
// Just drop the first few events going from 1 to 2 pointers.
|
|
// They're bad often enough that they're not worth considering.
|
|
if (lastNumPointers == 1 && nextNumPointers == 2
|
|
&& mJumpyPointsDropped < JUMPY_TRANSITION_DROPS) {
|
|
mNextNumPointers = 1;
|
|
mJumpyPointsDropped++;
|
|
} else if (lastNumPointers == 2 && nextNumPointers == 1
|
|
&& mJumpyPointsDropped < JUMPY_TRANSITION_DROPS) {
|
|
// The event when we go from 2 -> 1 tends to be messed up too
|
|
System.arraycopy(lastData, 0, nextData, 0,
|
|
lastNumPointers * MotionEvent.NUM_SAMPLE_DATA);
|
|
mNextNumPointers = lastNumPointers;
|
|
mJumpyPointsDropped++;
|
|
|
|
if (DEBUG_HACKS) {
|
|
for (int i = 0; i < mNextNumPointers; i++) {
|
|
int ioff = i * MotionEvent.NUM_SAMPLE_DATA;
|
|
Slog.d("InputDevice", "Pointer " + i + " replaced (" +
|
|
mNextData[ioff + MotionEvent.SAMPLE_X] + ", " +
|
|
mNextData[ioff + MotionEvent.SAMPLE_Y] + ")");
|
|
}
|
|
}
|
|
} else {
|
|
mJumpyPointsDropped = 0;
|
|
|
|
if (DEBUG_HACKS) {
|
|
Slog.d("InputDevice", "Transition - drop limit reset");
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
// A 'jumpy' point is one where the coordinate value for one axis
|
|
// has jumped to the other pointer's location. No need to do anything
|
|
// else if we only have one pointer.
|
|
if (nextNumPointers < 2) {
|
|
return;
|
|
}
|
|
|
|
int badPointerIndex = -1;
|
|
int badPointerReplaceXWith = 0;
|
|
int badPointerReplaceYWith = 0;
|
|
int badPointerDistance = Integer.MIN_VALUE;
|
|
for (int i = nextNumPointers - 1; i >= 0; i--) {
|
|
boolean dropx = false;
|
|
boolean dropy = false;
|
|
|
|
// Limit how many times a jumpy point can get dropped.
|
|
if (mJumpyPointsDropped < JUMPY_DROP_LIMIT) {
|
|
final int ioff = i * MotionEvent.NUM_SAMPLE_DATA;
|
|
final int x = nextData[ioff + MotionEvent.SAMPLE_X];
|
|
final int y = nextData[ioff + MotionEvent.SAMPLE_Y];
|
|
|
|
if (DEBUG_HACKS) {
|
|
Slog.d("InputDevice", "Point " + i + " (" + x + ", " + y + ")");
|
|
}
|
|
|
|
// Check if a touch point is too close to another's coordinates
|
|
for (int j = 0; j < nextNumPointers && !dropx && !dropy; j++) {
|
|
if (j == i) {
|
|
continue;
|
|
}
|
|
|
|
final int joff = j * MotionEvent.NUM_SAMPLE_DATA;
|
|
final int xOther = nextData[joff + MotionEvent.SAMPLE_X];
|
|
final int yOther = nextData[joff + MotionEvent.SAMPLE_Y];
|
|
|
|
dropx = Math.abs(x - xOther) <= jumpyEpsilon;
|
|
dropy = Math.abs(y - yOther) <= jumpyEpsilon;
|
|
}
|
|
|
|
if (dropx) {
|
|
int xreplace = lastData[MotionEvent.SAMPLE_X];
|
|
int yreplace = lastData[MotionEvent.SAMPLE_Y];
|
|
int distance = Math.abs(yreplace - y);
|
|
for (int j = 1; j < lastNumPointers; j++) {
|
|
final int joff = j * MotionEvent.NUM_SAMPLE_DATA;
|
|
int lasty = lastData[joff + MotionEvent.SAMPLE_Y];
|
|
int currDist = Math.abs(lasty - y);
|
|
if (currDist < distance) {
|
|
xreplace = lastData[joff + MotionEvent.SAMPLE_X];
|
|
yreplace = lasty;
|
|
distance = currDist;
|
|
}
|
|
}
|
|
|
|
int badXDelta = Math.abs(xreplace - x);
|
|
if (badXDelta > badPointerDistance) {
|
|
badPointerDistance = badXDelta;
|
|
badPointerIndex = i;
|
|
badPointerReplaceXWith = xreplace;
|
|
badPointerReplaceYWith = yreplace;
|
|
}
|
|
} else if (dropy) {
|
|
int xreplace = lastData[MotionEvent.SAMPLE_X];
|
|
int yreplace = lastData[MotionEvent.SAMPLE_Y];
|
|
int distance = Math.abs(xreplace - x);
|
|
for (int j = 1; j < lastNumPointers; j++) {
|
|
final int joff = j * MotionEvent.NUM_SAMPLE_DATA;
|
|
int lastx = lastData[joff + MotionEvent.SAMPLE_X];
|
|
int currDist = Math.abs(lastx - x);
|
|
if (currDist < distance) {
|
|
xreplace = lastx;
|
|
yreplace = lastData[joff + MotionEvent.SAMPLE_Y];
|
|
distance = currDist;
|
|
}
|
|
}
|
|
|
|
int badYDelta = Math.abs(yreplace - y);
|
|
if (badYDelta > badPointerDistance) {
|
|
badPointerDistance = badYDelta;
|
|
badPointerIndex = i;
|
|
badPointerReplaceXWith = xreplace;
|
|
badPointerReplaceYWith = yreplace;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (badPointerIndex >= 0) {
|
|
if (DEBUG_HACKS) {
|
|
Slog.d("InputDevice", "Replacing bad pointer " + badPointerIndex +
|
|
" with (" + badPointerReplaceXWith + ", " + badPointerReplaceYWith +
|
|
")");
|
|
}
|
|
|
|
final int offset = badPointerIndex * MotionEvent.NUM_SAMPLE_DATA;
|
|
nextData[offset + MotionEvent.SAMPLE_X] = badPointerReplaceXWith;
|
|
nextData[offset + MotionEvent.SAMPLE_Y] = badPointerReplaceYWith;
|
|
mJumpyPointsDropped++;
|
|
} else {
|
|
mJumpyPointsDropped = 0;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Special hack for devices that have bad screen data: aggregate and
|
|
* compute averages of the coordinate data, to reduce the amount of
|
|
* jitter seen by applications.
|
|
*/
|
|
int[] generateAveragedData(int upOrDownPointer, int lastNumPointers,
|
|
int nextNumPointers) {
|
|
final int numPointers = mLastNumPointers;
|
|
final int[] rawData = mLastData;
|
|
if (DEBUG_HACKS) Slog.v("InputDevice", "lastNumPointers=" + lastNumPointers
|
|
+ " nextNumPointers=" + nextNumPointers
|
|
+ " numPointers=" + numPointers);
|
|
for (int i=0; i<numPointers; i++) {
|
|
final int ioff = i * MotionEvent.NUM_SAMPLE_DATA;
|
|
// We keep the average data in offsets based on the pointer
|
|
// ID, so we don't need to move it around as fingers are
|
|
// pressed and released.
|
|
final int p = mPointerIds[i];
|
|
final int poff = p * MotionEvent.NUM_SAMPLE_DATA * HISTORY_SIZE;
|
|
if (i == upOrDownPointer && lastNumPointers != nextNumPointers) {
|
|
if (lastNumPointers < nextNumPointers) {
|
|
// This pointer is going down. Clear its history
|
|
// and start fresh.
|
|
if (DEBUG_HACKS) Slog.v("InputDevice", "Pointer down @ index "
|
|
+ upOrDownPointer + " id " + mPointerIds[i]);
|
|
mHistoryDataStart[i] = 0;
|
|
mHistoryDataEnd[i] = 0;
|
|
System.arraycopy(rawData, ioff, mHistoryData, poff,
|
|
MotionEvent.NUM_SAMPLE_DATA);
|
|
System.arraycopy(rawData, ioff, mAveragedData, ioff,
|
|
MotionEvent.NUM_SAMPLE_DATA);
|
|
continue;
|
|
} else {
|
|
// The pointer is going up. Just fall through to
|
|
// recompute the last averaged point (and don't add
|
|
// it as a new point to include in the average).
|
|
if (DEBUG_HACKS) Slog.v("InputDevice", "Pointer up @ index "
|
|
+ upOrDownPointer + " id " + mPointerIds[i]);
|
|
}
|
|
} else {
|
|
int end = mHistoryDataEnd[i];
|
|
int eoff = poff + (end*MotionEvent.NUM_SAMPLE_DATA);
|
|
int oldX = mHistoryData[eoff + MotionEvent.SAMPLE_X];
|
|
int oldY = mHistoryData[eoff + MotionEvent.SAMPLE_Y];
|
|
int newX = rawData[ioff + MotionEvent.SAMPLE_X];
|
|
int newY = rawData[ioff + MotionEvent.SAMPLE_Y];
|
|
int dx = newX-oldX;
|
|
int dy = newY-oldY;
|
|
int delta = dx*dx + dy*dy;
|
|
if (DEBUG_HACKS) Slog.v("InputDevice", "Delta from last: " + delta);
|
|
if (delta >= (75*75)) {
|
|
// Magic number, if moving farther than this, turn
|
|
// off filtering to avoid lag in response.
|
|
mHistoryDataStart[i] = 0;
|
|
mHistoryDataEnd[i] = 0;
|
|
System.arraycopy(rawData, ioff, mHistoryData, poff,
|
|
MotionEvent.NUM_SAMPLE_DATA);
|
|
System.arraycopy(rawData, ioff, mAveragedData, ioff,
|
|
MotionEvent.NUM_SAMPLE_DATA);
|
|
continue;
|
|
} else {
|
|
end++;
|
|
if (end >= HISTORY_SIZE) {
|
|
end -= HISTORY_SIZE;
|
|
}
|
|
mHistoryDataEnd[i] = end;
|
|
int noff = poff + (end*MotionEvent.NUM_SAMPLE_DATA);
|
|
mHistoryData[noff + MotionEvent.SAMPLE_X] = newX;
|
|
mHistoryData[noff + MotionEvent.SAMPLE_Y] = newY;
|
|
mHistoryData[noff + MotionEvent.SAMPLE_PRESSURE]
|
|
= rawData[ioff + MotionEvent.SAMPLE_PRESSURE];
|
|
int start = mHistoryDataStart[i];
|
|
if (end == start) {
|
|
start++;
|
|
if (start >= HISTORY_SIZE) {
|
|
start -= HISTORY_SIZE;
|
|
}
|
|
mHistoryDataStart[i] = start;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Now compute the average.
|
|
int start = mHistoryDataStart[i];
|
|
int end = mHistoryDataEnd[i];
|
|
int x=0, y=0;
|
|
int totalPressure = 0;
|
|
while (start != end) {
|
|
int soff = poff + (start*MotionEvent.NUM_SAMPLE_DATA);
|
|
int pressure = mHistoryData[soff + MotionEvent.SAMPLE_PRESSURE];
|
|
if (pressure <= 0) pressure = 1;
|
|
x += mHistoryData[soff + MotionEvent.SAMPLE_X] * pressure;
|
|
y += mHistoryData[soff + MotionEvent.SAMPLE_Y] * pressure;
|
|
totalPressure += pressure;
|
|
start++;
|
|
if (start >= HISTORY_SIZE) start = 0;
|
|
}
|
|
int eoff = poff + (end*MotionEvent.NUM_SAMPLE_DATA);
|
|
int pressure = mHistoryData[eoff + MotionEvent.SAMPLE_PRESSURE];
|
|
if (pressure <= 0) pressure = 1;
|
|
x += mHistoryData[eoff + MotionEvent.SAMPLE_X] * pressure;
|
|
y += mHistoryData[eoff + MotionEvent.SAMPLE_Y] * pressure;
|
|
totalPressure += pressure;
|
|
x /= totalPressure;
|
|
y /= totalPressure;
|
|
if (DEBUG_HACKS) Slog.v("InputDevice", "Averaging " + totalPressure
|
|
+ " weight: (" + x + "," + y + ")");
|
|
mAveragedData[ioff + MotionEvent.SAMPLE_X] = x;
|
|
mAveragedData[ioff + MotionEvent.SAMPLE_Y] = y;
|
|
mAveragedData[ioff + MotionEvent.SAMPLE_PRESSURE] =
|
|
rawData[ioff + MotionEvent.SAMPLE_PRESSURE];
|
|
mAveragedData[ioff + MotionEvent.SAMPLE_SIZE] =
|
|
rawData[ioff + MotionEvent.SAMPLE_SIZE];
|
|
}
|
|
return mAveragedData;
|
|
}
|
|
|
|
private boolean assignPointer(int nextIndex, boolean allowOverlap) {
|
|
final int lastNumPointers = mLastNumPointers;
|
|
final int[] next2Last = mNext2Last;
|
|
final long[] next2LastDistance = mNext2LastDistance;
|
|
final int[] last2Next = mLast2Next;
|
|
final int[] lastData = mLastData;
|
|
final int[] nextData = mNextData;
|
|
final int id = nextIndex * MotionEvent.NUM_SAMPLE_DATA;
|
|
|
|
if (DEBUG_POINTERS) Slog.v("InputDevice", "assignPointer: nextIndex="
|
|
+ nextIndex + " dataOff=" + id);
|
|
final int x1 = nextData[id + MotionEvent.SAMPLE_X];
|
|
final int y1 = nextData[id + MotionEvent.SAMPLE_Y];
|
|
|
|
long bestDistance = -1;
|
|
int bestIndex = -1;
|
|
for (int j=0; j<lastNumPointers; j++) {
|
|
// If we are not allowing multiple new points to be assigned
|
|
// to the same old pointer, then skip this one if it is already
|
|
// detected as a conflict (-2).
|
|
if (!allowOverlap && last2Next[j] < -1) {
|
|
continue;
|
|
}
|
|
final int jd = j * MotionEvent.NUM_SAMPLE_DATA;
|
|
final int xd = lastData[jd + MotionEvent.SAMPLE_X] - x1;
|
|
final int yd = lastData[jd + MotionEvent.SAMPLE_Y] - y1;
|
|
final long distance = xd*(long)xd + yd*(long)yd;
|
|
if (bestDistance == -1 || distance < bestDistance) {
|
|
bestDistance = distance;
|
|
bestIndex = j;
|
|
}
|
|
}
|
|
|
|
if (DEBUG_POINTERS) Slog.v("InputDevice", "New index " + nextIndex
|
|
+ " best old index=" + bestIndex + " (distance="
|
|
+ bestDistance + ")");
|
|
next2Last[nextIndex] = bestIndex;
|
|
next2LastDistance[nextIndex] = bestDistance;
|
|
|
|
if (bestIndex < 0) {
|
|
return true;
|
|
}
|
|
|
|
if (last2Next[bestIndex] == -1) {
|
|
last2Next[bestIndex] = nextIndex;
|
|
return false;
|
|
}
|
|
|
|
if (DEBUG_POINTERS) Slog.v("InputDevice", "Old index " + bestIndex
|
|
+ " has multiple best new pointers!");
|
|
|
|
last2Next[bestIndex] = -2;
|
|
return true;
|
|
}
|
|
|
|
private int updatePointerIdentifiers() {
|
|
final int[] lastData = mLastData;
|
|
final int[] nextData = mNextData;
|
|
final int nextNumPointers = mNextNumPointers;
|
|
final int lastNumPointers = mLastNumPointers;
|
|
|
|
if (nextNumPointers == 1 && lastNumPointers == 1) {
|
|
System.arraycopy(nextData, 0, lastData, 0,
|
|
MotionEvent.NUM_SAMPLE_DATA);
|
|
return -1;
|
|
}
|
|
|
|
// Clear our old state.
|
|
final int[] last2Next = mLast2Next;
|
|
for (int i=0; i<lastNumPointers; i++) {
|
|
last2Next[i] = -1;
|
|
}
|
|
|
|
if (DEBUG_POINTERS) Slog.v("InputDevice",
|
|
"Update pointers: lastNumPointers=" + lastNumPointers
|
|
+ " nextNumPointers=" + nextNumPointers);
|
|
|
|
// Figure out the closes new points to the previous points.
|
|
final int[] next2Last = mNext2Last;
|
|
final long[] next2LastDistance = mNext2LastDistance;
|
|
boolean conflicts = false;
|
|
for (int i=0; i<nextNumPointers; i++) {
|
|
conflicts |= assignPointer(i, true);
|
|
}
|
|
|
|
// Resolve ambiguities in pointer mappings, when two or more
|
|
// new pointer locations find their best previous location is
|
|
// the same.
|
|
if (conflicts) {
|
|
if (DEBUG_POINTERS) Slog.v("InputDevice", "Resolving conflicts");
|
|
|
|
for (int i=0; i<lastNumPointers; i++) {
|
|
if (last2Next[i] != -2) {
|
|
continue;
|
|
}
|
|
|
|
// Note that this algorithm is far from perfect. Ideally
|
|
// we should do something like the one described at
|
|
// http://portal.acm.org/citation.cfm?id=997856
|
|
|
|
if (DEBUG_POINTERS) Slog.v("InputDevice",
|
|
"Resolving last index #" + i);
|
|
|
|
int numFound;
|
|
do {
|
|
numFound = 0;
|
|
long worstDistance = 0;
|
|
int worstJ = -1;
|
|
for (int j=0; j<nextNumPointers; j++) {
|
|
if (next2Last[j] != i) {
|
|
continue;
|
|
}
|
|
numFound++;
|
|
if (worstDistance < next2LastDistance[j]) {
|
|
worstDistance = next2LastDistance[j];
|
|
worstJ = j;
|
|
}
|
|
}
|
|
|
|
if (worstJ >= 0) {
|
|
if (DEBUG_POINTERS) Slog.v("InputDevice",
|
|
"Worst new pointer: " + worstJ
|
|
+ " (distance=" + worstDistance + ")");
|
|
if (assignPointer(worstJ, false)) {
|
|
// In this case there is no last pointer
|
|
// remaining for this new one!
|
|
next2Last[worstJ] = -1;
|
|
}
|
|
}
|
|
} while (numFound > 2);
|
|
}
|
|
}
|
|
|
|
int retIndex = -1;
|
|
|
|
if (lastNumPointers < nextNumPointers) {
|
|
// We have one or more new pointers that are down. Create a
|
|
// new pointer identifier for one of them.
|
|
if (DEBUG_POINTERS) Slog.v("InputDevice", "Adding new pointer");
|
|
int nextId = 0;
|
|
int i=0;
|
|
while (i < lastNumPointers) {
|
|
if (mPointerIds[i] > nextId) {
|
|
// Found a hole, insert the pointer here.
|
|
if (DEBUG_POINTERS) Slog.v("InputDevice",
|
|
"Inserting new pointer at hole " + i);
|
|
System.arraycopy(mPointerIds, i, mPointerIds,
|
|
i+1, lastNumPointers-i);
|
|
System.arraycopy(lastData, i*MotionEvent.NUM_SAMPLE_DATA,
|
|
lastData, (i+1)*MotionEvent.NUM_SAMPLE_DATA,
|
|
(lastNumPointers-i)*MotionEvent.NUM_SAMPLE_DATA);
|
|
break;
|
|
}
|
|
i++;
|
|
nextId++;
|
|
}
|
|
|
|
if (DEBUG_POINTERS) Slog.v("InputDevice",
|
|
"New pointer id " + nextId + " at index " + i);
|
|
|
|
mLastNumPointers++;
|
|
retIndex = i;
|
|
mPointerIds[i] = nextId;
|
|
|
|
// And assign this identifier to the first new pointer.
|
|
for (int j=0; j<nextNumPointers; j++) {
|
|
if (next2Last[j] < 0) {
|
|
if (DEBUG_POINTERS) Slog.v("InputDevice",
|
|
"Assigning new id to new pointer index " + j);
|
|
next2Last[j] = i;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Propagate all of the current data into the appropriate
|
|
// location in the old data to match the pointer ID that was
|
|
// assigned to it.
|
|
for (int i=0; i<nextNumPointers; i++) {
|
|
int lastIndex = next2Last[i];
|
|
if (lastIndex >= 0) {
|
|
if (DEBUG_POINTERS) Slog.v("InputDevice",
|
|
"Copying next pointer index " + i
|
|
+ " to last index " + lastIndex);
|
|
System.arraycopy(nextData, i*MotionEvent.NUM_SAMPLE_DATA,
|
|
lastData, lastIndex*MotionEvent.NUM_SAMPLE_DATA,
|
|
MotionEvent.NUM_SAMPLE_DATA);
|
|
}
|
|
}
|
|
|
|
if (lastNumPointers > nextNumPointers) {
|
|
// One or more pointers has gone up. Find the first one,
|
|
// and adjust accordingly.
|
|
if (DEBUG_POINTERS) Slog.v("InputDevice", "Removing old pointer");
|
|
for (int i=0; i<lastNumPointers; i++) {
|
|
if (last2Next[i] == -1) {
|
|
if (DEBUG_POINTERS) Slog.v("InputDevice",
|
|
"Removing old pointer at index " + i);
|
|
retIndex = i;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return retIndex;
|
|
}
|
|
|
|
void removeOldPointer(int index) {
|
|
final int lastNumPointers = mLastNumPointers;
|
|
if (index >= 0 && index < lastNumPointers) {
|
|
System.arraycopy(mPointerIds, index+1, mPointerIds,
|
|
index, lastNumPointers-index-1);
|
|
System.arraycopy(mLastData, (index+1)*MotionEvent.NUM_SAMPLE_DATA,
|
|
mLastData, (index)*MotionEvent.NUM_SAMPLE_DATA,
|
|
(lastNumPointers-index-1)*MotionEvent.NUM_SAMPLE_DATA);
|
|
mLastNumPointers--;
|
|
}
|
|
}
|
|
|
|
MotionEvent generateAbsMotion(InputDevice device, long curTime,
|
|
long curTimeNano, Display display, int orientation,
|
|
int metaState) {
|
|
|
|
if (mSkipLastPointers) {
|
|
mSkipLastPointers = false;
|
|
mLastNumPointers = 0;
|
|
}
|
|
|
|
if (mNextNumPointers <= 0 && mLastNumPointers <= 0) {
|
|
return null;
|
|
}
|
|
|
|
final int lastNumPointers = mLastNumPointers;
|
|
final int nextNumPointers = mNextNumPointers;
|
|
if (mNextNumPointers > MAX_POINTERS) {
|
|
Slog.w("InputDevice", "Number of pointers " + mNextNumPointers
|
|
+ " exceeded maximum of " + MAX_POINTERS);
|
|
mNextNumPointers = MAX_POINTERS;
|
|
}
|
|
|
|
int upOrDownPointer = updatePointerIdentifiers();
|
|
|
|
final float[] reportData = mReportData;
|
|
final int[] rawData;
|
|
if (KeyInputQueue.BAD_TOUCH_HACK) {
|
|
rawData = generateAveragedData(upOrDownPointer, lastNumPointers,
|
|
nextNumPointers);
|
|
} else {
|
|
rawData = mLastData;
|
|
}
|
|
|
|
final int numPointers = mLastNumPointers;
|
|
|
|
if (DEBUG_POINTERS) Slog.v("InputDevice", "Processing "
|
|
+ numPointers + " pointers (going from " + lastNumPointers
|
|
+ " to " + nextNumPointers + ")");
|
|
|
|
for (int i=0; i<numPointers; i++) {
|
|
final int pos = i * MotionEvent.NUM_SAMPLE_DATA;
|
|
reportData[pos + MotionEvent.SAMPLE_X] = rawData[pos + MotionEvent.SAMPLE_X];
|
|
reportData[pos + MotionEvent.SAMPLE_Y] = rawData[pos + MotionEvent.SAMPLE_Y];
|
|
reportData[pos + MotionEvent.SAMPLE_PRESSURE] = rawData[pos + MotionEvent.SAMPLE_PRESSURE];
|
|
reportData[pos + MotionEvent.SAMPLE_SIZE] = rawData[pos + MotionEvent.SAMPLE_SIZE];
|
|
}
|
|
|
|
int action;
|
|
int edgeFlags = 0;
|
|
if (nextNumPointers != lastNumPointers) {
|
|
if (nextNumPointers > lastNumPointers) {
|
|
if (lastNumPointers == 0) {
|
|
action = MotionEvent.ACTION_DOWN;
|
|
mDownTime = curTime;
|
|
} else {
|
|
action = MotionEvent.ACTION_POINTER_DOWN
|
|
| (upOrDownPointer << MotionEvent.ACTION_POINTER_INDEX_SHIFT);
|
|
}
|
|
} else {
|
|
if (numPointers == 1) {
|
|
action = MotionEvent.ACTION_UP;
|
|
} else {
|
|
action = MotionEvent.ACTION_POINTER_UP
|
|
| (upOrDownPointer << MotionEvent.ACTION_POINTER_INDEX_SHIFT);
|
|
}
|
|
}
|
|
currentMove = null;
|
|
} else {
|
|
action = MotionEvent.ACTION_MOVE;
|
|
}
|
|
|
|
final int dispW = display.getWidth()-1;
|
|
final int dispH = display.getHeight()-1;
|
|
int w = dispW;
|
|
int h = dispH;
|
|
if (orientation == Surface.ROTATION_90
|
|
|| orientation == Surface.ROTATION_270) {
|
|
int tmp = w;
|
|
w = h;
|
|
h = tmp;
|
|
}
|
|
|
|
final AbsoluteInfo absX = device.absX;
|
|
final AbsoluteInfo absY = device.absY;
|
|
final AbsoluteInfo absPressure = device.absPressure;
|
|
final AbsoluteInfo absSize = device.absSize;
|
|
for (int i=0; i<numPointers; i++) {
|
|
final int j = i * MotionEvent.NUM_SAMPLE_DATA;
|
|
|
|
if (absX != null) {
|
|
reportData[j + MotionEvent.SAMPLE_X] =
|
|
((reportData[j + MotionEvent.SAMPLE_X]-absX.minValue)
|
|
/ absX.range) * w;
|
|
}
|
|
if (absY != null) {
|
|
reportData[j + MotionEvent.SAMPLE_Y] =
|
|
((reportData[j + MotionEvent.SAMPLE_Y]-absY.minValue)
|
|
/ absY.range) * h;
|
|
}
|
|
if (absPressure != null) {
|
|
reportData[j + MotionEvent.SAMPLE_PRESSURE] =
|
|
((reportData[j + MotionEvent.SAMPLE_PRESSURE]-absPressure.minValue)
|
|
/ (float)absPressure.range);
|
|
}
|
|
if (absSize != null) {
|
|
reportData[j + MotionEvent.SAMPLE_SIZE] =
|
|
((reportData[j + MotionEvent.SAMPLE_SIZE]-absSize.minValue)
|
|
/ (float)absSize.range);
|
|
}
|
|
|
|
switch (orientation) {
|
|
case Surface.ROTATION_90: {
|
|
final float temp = reportData[j + MotionEvent.SAMPLE_X];
|
|
reportData[j + MotionEvent.SAMPLE_X] = reportData[j + MotionEvent.SAMPLE_Y];
|
|
reportData[j + MotionEvent.SAMPLE_Y] = w-temp;
|
|
break;
|
|
}
|
|
case Surface.ROTATION_180: {
|
|
reportData[j + MotionEvent.SAMPLE_X] = w-reportData[j + MotionEvent.SAMPLE_X];
|
|
reportData[j + MotionEvent.SAMPLE_Y] = h-reportData[j + MotionEvent.SAMPLE_Y];
|
|
break;
|
|
}
|
|
case Surface.ROTATION_270: {
|
|
final float temp = reportData[j + MotionEvent.SAMPLE_X];
|
|
reportData[j + MotionEvent.SAMPLE_X] = h-reportData[j + MotionEvent.SAMPLE_Y];
|
|
reportData[j + MotionEvent.SAMPLE_Y] = temp;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// We only consider the first pointer when computing the edge
|
|
// flags, since they are global to the event.
|
|
if (action == MotionEvent.ACTION_DOWN) {
|
|
if (reportData[MotionEvent.SAMPLE_X] <= 0) {
|
|
edgeFlags |= MotionEvent.EDGE_LEFT;
|
|
} else if (reportData[MotionEvent.SAMPLE_X] >= dispW) {
|
|
edgeFlags |= MotionEvent.EDGE_RIGHT;
|
|
}
|
|
if (reportData[MotionEvent.SAMPLE_Y] <= 0) {
|
|
edgeFlags |= MotionEvent.EDGE_TOP;
|
|
} else if (reportData[MotionEvent.SAMPLE_Y] >= dispH) {
|
|
edgeFlags |= MotionEvent.EDGE_BOTTOM;
|
|
}
|
|
}
|
|
|
|
if (currentMove != null) {
|
|
if (false) Slog.i("InputDevice", "Adding batch x="
|
|
+ reportData[MotionEvent.SAMPLE_X]
|
|
+ " y=" + reportData[MotionEvent.SAMPLE_Y]
|
|
+ " to " + currentMove);
|
|
currentMove.addBatch(curTime, reportData, metaState);
|
|
if (WindowManagerPolicy.WATCH_POINTER) {
|
|
Slog.i("KeyInputQueue", "Updating: " + currentMove);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
MotionEvent me = MotionEvent.obtainNano(mDownTime, curTime,
|
|
curTimeNano, action, numPointers, mPointerIds, reportData,
|
|
metaState, xPrecision, yPrecision, device.id, edgeFlags);
|
|
if (action == MotionEvent.ACTION_MOVE) {
|
|
currentMove = me;
|
|
}
|
|
|
|
if (nextNumPointers < lastNumPointers) {
|
|
removeOldPointer(upOrDownPointer);
|
|
}
|
|
|
|
return me;
|
|
}
|
|
|
|
boolean hasMore() {
|
|
return mLastNumPointers != mNextNumPointers;
|
|
}
|
|
|
|
void finish() {
|
|
mNextNumPointers = mAddingPointerOffset = 0;
|
|
mNextData[MotionEvent.SAMPLE_PRESSURE] = 0;
|
|
}
|
|
|
|
MotionEvent generateRelMotion(InputDevice device, long curTime,
|
|
long curTimeNano, int orientation, int metaState) {
|
|
|
|
final float[] scaled = mReportData;
|
|
|
|
// For now we only support 1 pointer with relative motions.
|
|
scaled[MotionEvent.SAMPLE_X] = mNextData[MotionEvent.SAMPLE_X];
|
|
scaled[MotionEvent.SAMPLE_Y] = mNextData[MotionEvent.SAMPLE_Y];
|
|
scaled[MotionEvent.SAMPLE_PRESSURE] = 1.0f;
|
|
scaled[MotionEvent.SAMPLE_SIZE] = 0;
|
|
int edgeFlags = 0;
|
|
|
|
int action;
|
|
if (mNextNumPointers != mLastNumPointers) {
|
|
mNextData[MotionEvent.SAMPLE_X] =
|
|
mNextData[MotionEvent.SAMPLE_Y] = 0;
|
|
if (mNextNumPointers > 0 && mLastNumPointers == 0) {
|
|
action = MotionEvent.ACTION_DOWN;
|
|
mDownTime = curTime;
|
|
} else if (mNextNumPointers == 0) {
|
|
action = MotionEvent.ACTION_UP;
|
|
} else {
|
|
action = MotionEvent.ACTION_MOVE;
|
|
}
|
|
mLastNumPointers = mNextNumPointers;
|
|
currentMove = null;
|
|
} else {
|
|
action = MotionEvent.ACTION_MOVE;
|
|
}
|
|
|
|
scaled[MotionEvent.SAMPLE_X] *= xMoveScale;
|
|
scaled[MotionEvent.SAMPLE_Y] *= yMoveScale;
|
|
switch (orientation) {
|
|
case Surface.ROTATION_90: {
|
|
final float temp = scaled[MotionEvent.SAMPLE_X];
|
|
scaled[MotionEvent.SAMPLE_X] = scaled[MotionEvent.SAMPLE_Y];
|
|
scaled[MotionEvent.SAMPLE_Y] = -temp;
|
|
break;
|
|
}
|
|
case Surface.ROTATION_180: {
|
|
scaled[MotionEvent.SAMPLE_X] = -scaled[MotionEvent.SAMPLE_X];
|
|
scaled[MotionEvent.SAMPLE_Y] = -scaled[MotionEvent.SAMPLE_Y];
|
|
break;
|
|
}
|
|
case Surface.ROTATION_270: {
|
|
final float temp = scaled[MotionEvent.SAMPLE_X];
|
|
scaled[MotionEvent.SAMPLE_X] = -scaled[MotionEvent.SAMPLE_Y];
|
|
scaled[MotionEvent.SAMPLE_Y] = temp;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (currentMove != null) {
|
|
if (false) Slog.i("InputDevice", "Adding batch x="
|
|
+ scaled[MotionEvent.SAMPLE_X]
|
|
+ " y=" + scaled[MotionEvent.SAMPLE_Y]
|
|
+ " to " + currentMove);
|
|
currentMove.addBatch(curTime, scaled, metaState);
|
|
if (WindowManagerPolicy.WATCH_POINTER) {
|
|
Slog.i("KeyInputQueue", "Updating: " + currentMove);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
MotionEvent me = MotionEvent.obtainNano(mDownTime, curTime,
|
|
curTimeNano, action, 1, mPointerIds, scaled, metaState,
|
|
xPrecision, yPrecision, device.id, edgeFlags);
|
|
if (action == MotionEvent.ACTION_MOVE) {
|
|
currentMove = me;
|
|
}
|
|
return me;
|
|
}
|
|
}
|
|
|
|
static class AbsoluteInfo {
|
|
int minValue;
|
|
int maxValue;
|
|
int range;
|
|
int flat;
|
|
int fuzz;
|
|
|
|
final void dump(PrintWriter pw) {
|
|
pw.print("minValue="); pw.print(minValue);
|
|
pw.print(" maxValue="); pw.print(maxValue);
|
|
pw.print(" range="); pw.print(range);
|
|
pw.print(" flat="); pw.print(flat);
|
|
pw.print(" fuzz="); pw.print(fuzz);
|
|
}
|
|
};
|
|
|
|
InputDevice(int _id, int _classes, String _name,
|
|
AbsoluteInfo _absX, AbsoluteInfo _absY,
|
|
AbsoluteInfo _absPressure, AbsoluteInfo _absSize) {
|
|
id = _id;
|
|
classes = _classes;
|
|
name = _name;
|
|
absX = _absX;
|
|
absY = _absY;
|
|
absPressure = _absPressure;
|
|
absSize = _absSize;
|
|
}
|
|
};
|