diff options
Diffstat (limited to 'core/java/android/view/MotionEvent.java')
| -rw-r--r-- | core/java/android/view/MotionEvent.java | 1342 |
1 files changed, 809 insertions, 533 deletions
diff --git a/core/java/android/view/MotionEvent.java b/core/java/android/view/MotionEvent.java index 5db4895..6673be2 100644 --- a/core/java/android/view/MotionEvent.java +++ b/core/java/android/view/MotionEvent.java @@ -102,7 +102,7 @@ import android.os.SystemClock; * </p> */ public final class MotionEvent extends InputEvent implements Parcelable { - private static final long MS_PER_NS = 1000000; + private static final long NS_PER_MS = 1000000; private static final boolean TRACK_RECYCLED_LOCATION = false; /** @@ -261,123 +261,241 @@ public final class MotionEvent extends InputEvent implements Parcelable { */ public static final int EDGE_RIGHT = 0x00000008; - /* - * Offset for the sample's X coordinate. - */ - static private final int SAMPLE_X = 0; - - /* - * Offset for the sample's Y coordinate. - */ - static private final int SAMPLE_Y = 1; - - /* - * Offset for the sample's pressure. - */ - static private final int SAMPLE_PRESSURE = 2; - - /* - * Offset for the sample's size + /** + * Constant used to identify the X axis of a motion event. + * + * The interpretation of the X axis varies by input source. + * It may represent the X position of the center of the touch contact area, + * a relative horizontal displacement of a trackball or joystick, or something else. + * + * @see #getX(int) + * @see #getHistoricalX(int, int) + * @see MotionEvent.PointerCoords#x + * @see InputDevice#getMotionRange */ - static private final int SAMPLE_SIZE = 3; - - /* - * Offset for the sample's touch major axis length. + public static final int AXIS_X = 0; + + /** + * Constant used to identify the Y axis of a motion event. + * + * The interpretation of the Y axis varies by input source. + * It may represent the Y position of the center of the touch contact area, + * a relative vertical displacement of a trackball or joystick, or something else. + * + * @see #getY(int) + * @see #getHistoricalY(int, int) + * @see MotionEvent.PointerCoords#y + * @see InputDevice#getMotionRange */ - static private final int SAMPLE_TOUCH_MAJOR = 4; + public static final int AXIS_Y = 1; - /* - * Offset for the sample's touch minor axis length. + /** + * Constant used to identify the Pressure axis of a motion event. + * + * The pressure axis specifies a normalized value that describes the approximate + * pressure applied to the device by a finger or other tool. + * The pressure generally ranges from 0 (no pressure at all) to 1 (normal pressure), + * although values higher than 1 may be generated depending on the calibration of + * the input device. + * + * @see #getPressure(int) + * @see #getHistoricalPressure(int, int) + * @see MotionEvent.PointerCoords#pressure + * @see InputDevice#getMotionRange */ - static private final int SAMPLE_TOUCH_MINOR = 5; - - /* - * Offset for the sample's tool major axis length. + public static final int AXIS_PRESSURE = 2; + + /** + * Constant used to identify the Size axis of a motion event. + * + * The size axis specifies a normalized value that describes the approximate size + * of the pointer touch area in relation to the maximum detectable size for the device. + * It represents some approximation of the area of the screen being + * pressed; the actual value in pixels corresponding to the + * touch is normalized with the device specific range of values + * and scaled to a value between 0 and 1. The value of size can be used to + * determine fat touch events. + * + * To obtain calibrated size information in terms of pixels, use + * {@link #AXIS_TOUCH_MAJOR} or {@link #AXIS_TOOL_MAJOR} instead. + * + * @see #getSize(int) + * @see #getHistoricalSize(int, int) + * @see MotionEvent.PointerCoords#size + * @see InputDevice#getMotionRange */ - static private final int SAMPLE_TOOL_MAJOR = 6; + public static final int AXIS_SIZE = 3; - /* - * Offset for the sample's tool minor axis length. + /** + * Constant used to identify the TouchMajor axis of a motion event. + * + * The touch major axis specifies the length of the major axis of an ellipse that + * describes the touch area at the point of contact. + * If the device is a touch screen, the length is reported in pixels, otherwise it is + * reported in device-specific units. + * + * @see #getTouchMajor(int) + * @see #getHistoricalTouchMajor(int, int) + * @see MotionEvent.PointerCoords#touchMajor + * @see InputDevice#getMotionRange */ - static private final int SAMPLE_TOOL_MINOR = 7; - - /* - * Offset for the sample's orientation. + public static final int AXIS_TOUCH_MAJOR = 4; + + /** + * Constant used to identify the TouchMinor axis of a motion event. + * + * The touch major axis specifies the length of the minor axis of an ellipse that + * describes the touch area at the point of contact. + * If the device is a touch screen, the length is reported in pixels, otherwise it is + * reported in device-specific units. + * + * @see #getTouchMinor(int) + * @see #getHistoricalTouchMinor(int, int) + * @see MotionEvent.PointerCoords#touchMinor + * @see InputDevice#getMotionRange */ - static private final int SAMPLE_ORIENTATION = 8; + public static final int AXIS_TOUCH_MINOR = 5; - /* - * Number of data items for each sample. + /** + * Constant used to identify the ToolMajor axis of a motion event. + * + * The tool major axis specifies the length of the major axis of an ellipse that + * describes the size of the approaching tool. + * The tool area represents the estimated size of the finger or pen that is + * touching the device independent of its actual touch area at the point of contact. + * If the device is a touch screen, the length is reported in pixels, otherwise it is + * reported in device-specific units. + * + * @see #getToolMajor(int) + * @see #getHistoricalToolMajor(int, int) + * @see MotionEvent.PointerCoords#toolMajor + * @see InputDevice#getMotionRange */ - static private final int NUM_SAMPLE_DATA = 9; - - /* - * Minimum number of pointers for which to reserve space when allocating new - * motion events. This is explicitly not a bound on the maximum number of pointers. + public static final int AXIS_TOOL_MAJOR = 6; + + /** + * Constant used to identify the ToolMinor axis of a motion event. + * + * The tool minor axis specifies the length of the major axis of an ellipse that + * describes the size of the approaching tool. + * The tool area represents the estimated size of the finger or pen that is + * touching the device independent of its actual touch area at the point of contact. + * If the device is a touch screen, the length is reported in pixels, otherwise it is + * reported in device-specific units. + * + * @see #getToolMinor(int) + * @see #getHistoricalToolMinor(int, int) + * @see MotionEvent.PointerCoords#toolMinor + * @see InputDevice#getMotionRange */ - static private final int BASE_AVAIL_POINTERS = 5; - - /* - * Minimum number of samples for which to reserve space when allocating new motion events. + public static final int AXIS_TOOL_MINOR = 7; + + /** + * Constant used to identify the Orientation axis of a motion event. + * + * The orientation axis specifies the orientation of the touch area and tool area in + * radians clockwise from vertical relative to the vertical plane of the device. + * An angle of 0 degrees indicates that the major axis of contact is oriented + * upwards, is perfectly circular or is of unknown orientation. A positive angle + * indicates that the major axis of contact is oriented to the right. A negative angle + * indicates that the major axis of contact is oriented to the left. + * The full range is from -PI/2 radians (finger pointing fully left) to PI/2 radians + * (finger pointing fully right). + * + * @see #getOrientation(int) + * @see #getHistoricalOrientation(int, int) + * @see MotionEvent.PointerCoords#orientation + * @see InputDevice#getMotionRange */ - static private final int BASE_AVAIL_SAMPLES = 8; - + public static final int AXIS_ORIENTATION = 8; + + // Private value for history pos that obtains the current sample. + private static final int HISTORY_CURRENT = -0x80000000; + private static final int MAX_RECYCLED = 10; private static final Object gRecyclerLock = new Object(); private static int gRecyclerUsed; private static MotionEvent gRecyclerTop; - private long mDownTimeNano; - private int mAction; - private float mXOffset; - private float mYOffset; - private float mXPrecision; - private float mYPrecision; - private int mEdgeFlags; - private int mMetaState; - private int mFlags; - - private int mNumPointers; - private int mNumSamples; - - private int mLastDataSampleIndex; - private int mLastEventTimeNanoSampleIndex; - - // Array of mNumPointers size of identifiers for each pointer of data. - private int[] mPointerIdentifiers; - - // Array of (mNumSamples * mNumPointers * NUM_SAMPLE_DATA) size of event data. - // Samples are ordered from oldest to newest. - private float[] mDataSamples; - - // Array of mNumSamples size of event time stamps in nanoseconds. - // Samples are ordered from oldest to newest. - private long[] mEventTimeNanoSamples; + // Shared temporary objects used when translating coordinates supplied by + // the caller into single element PointerCoords and pointer id arrays. + // Must lock gTmpPointerCoords prior to use. + private static final PointerCoords[] gTmpPointerCoords = + new PointerCoords[] { new PointerCoords() }; + private static final int[] gTmpPointerIds = new int[] { 0 /*always 0*/ }; + + // Pointer to the native MotionEvent object that contains the actual data. + private int mNativePtr; private MotionEvent mNext; private RuntimeException mRecycledLocation; private boolean mRecycled; - private native void nativeTransform(Matrix matrix); + private static native int nativeInitialize(int nativePtr, + int deviceId, int source, int action, int flags, int edgeFlags, int metaState, + float xOffset, float yOffset, float xPrecision, float yPrecision, + long downTimeNanos, long eventTimeNanos, + int pointerCount, int[] pointerIds, PointerCoords[] pointerCoords); + private static native int nativeCopy(int destNativePtr, int sourceNativePtr, + boolean keepHistory); + private static native void nativeDispose(int nativePtr); + private static native void nativeAddBatch(int nativePtr, long eventTimeNanos, + PointerCoords[] pointerCoords, int metaState); + + private static native int nativeGetDeviceId(int nativePtr); + private static native int nativeGetSource(int nativePtr); + private static native int nativeSetSource(int nativePtr, int source); + private static native int nativeGetAction(int nativePtr); + private static native void nativeSetAction(int nativePtr, int action); + private static native int nativeGetFlags(int nativePtr); + private static native int nativeGetEdgeFlags(int nativePtr); + private static native void nativeSetEdgeFlags(int nativePtr, int action); + private static native int nativeGetMetaState(int nativePtr); + private static native void nativeOffsetLocation(int nativePtr, float deltaX, float deltaY); + private static native float nativeGetXPrecision(int nativePtr); + private static native float nativeGetYPrecision(int nativePtr); + private static native long nativeGetDownTimeNanos(int nativePtr); + + private static native int nativeGetPointerCount(int nativePtr); + private static native int nativeGetPointerId(int nativePtr, int pointerIndex); + private static native int nativeFindPointerIndex(int nativePtr, int pointerId); + + private static native int nativeGetHistorySize(int nativePtr); + private static native long nativeGetEventTimeNanos(int nativePtr, int historyPos); + private static native float nativeGetRawAxisValue(int nativePtr, + int axis, int pointerIndex, int historyPos); + private static native float nativeGetAxisValue(int nativePtr, + int axis, int pointerIndex, int historyPos); + private static native void nativeGetPointerCoords(int nativePtr, + int pointerIndex, int historyPos, PointerCoords outPointerCoords); + + private static native void nativeScale(int nativePtr, float scale); + private static native void nativeTransform(int nativePtr, Matrix matrix); + + private static native int nativeReadFromParcel(int nativePtr, Parcel parcel); + private static native void nativeWriteToParcel(int nativePtr, Parcel parcel); + + private MotionEvent() { + } - private MotionEvent(int pointerCount, int sampleCount) { - mPointerIdentifiers = new int[pointerCount]; - mDataSamples = new float[pointerCount * sampleCount * NUM_SAMPLE_DATA]; - mEventTimeNanoSamples = new long[sampleCount]; + @Override + protected void finalize() throws Throwable { + try { + if (mNativePtr != 0) { + nativeDispose(mNativePtr); + mNativePtr = 0; + } + } finally { + super.finalize(); + } } - static private MotionEvent obtain(int pointerCount, int sampleCount) { + static private MotionEvent obtain() { final MotionEvent ev; synchronized (gRecyclerLock) { ev = gRecyclerTop; if (ev == null) { - if (pointerCount < BASE_AVAIL_POINTERS) { - pointerCount = BASE_AVAIL_POINTERS; - } - if (sampleCount < BASE_AVAIL_SAMPLES) { - sampleCount = BASE_AVAIL_SAMPLES; - } - return new MotionEvent(pointerCount, sampleCount); + return new MotionEvent(); } gRecyclerTop = ev.mNext; gRecyclerUsed -= 1; @@ -385,23 +503,9 @@ public final class MotionEvent extends InputEvent implements Parcelable { ev.mRecycledLocation = null; ev.mRecycled = false; ev.mNext = null; - - if (ev.mPointerIdentifiers.length < pointerCount) { - ev.mPointerIdentifiers = new int[pointerCount]; - } - - if (ev.mEventTimeNanoSamples.length < sampleCount) { - ev.mEventTimeNanoSamples = new long[sampleCount]; - } - - final int neededDataSamplesLength = pointerCount * sampleCount * NUM_SAMPLE_DATA; - if (ev.mDataSamples.length < neededDataSamplesLength) { - ev.mDataSamples = new float[neededDataSamplesLength]; - } - return ev; } - + /** * Create a new MotionEvent, filling in all of the basic values that * define the motion. @@ -434,34 +538,15 @@ public final class MotionEvent extends InputEvent implements Parcelable { int action, int pointers, int[] pointerIds, PointerCoords[] pointerCoords, int metaState, float xPrecision, float yPrecision, int deviceId, int edgeFlags, int source, int flags) { - MotionEvent ev = obtain(pointers, 1); - ev.mDeviceId = deviceId; - ev.mSource = source; - ev.mEdgeFlags = edgeFlags; - ev.mDownTimeNano = downTime * MS_PER_NS; - ev.mAction = action; - ev.mFlags = flags; - ev.mMetaState = metaState; - ev.mXOffset = 0; - ev.mYOffset = 0; - ev.mXPrecision = xPrecision; - ev.mYPrecision = yPrecision; - - ev.mNumPointers = pointers; - ev.mNumSamples = 1; - - ev.mLastDataSampleIndex = 0; - ev.mLastEventTimeNanoSampleIndex = 0; - - System.arraycopy(pointerIds, 0, ev.mPointerIdentifiers, 0, pointers); - - ev.mEventTimeNanoSamples[0] = eventTime * MS_PER_NS; - - ev.setPointerCoordsAtSampleIndex(0, pointerCoords); - + MotionEvent ev = obtain(); + ev.mNativePtr = nativeInitialize(ev.mNativePtr, + deviceId, source, action, flags, edgeFlags, metaState, + 0, 0, xPrecision, yPrecision, + downTime * NS_PER_MS, eventTime * NS_PER_MS, + pointers, pointerIds, pointerCoords); return ev; } - + /** * Create a new MotionEvent, filling in all of the basic values that * define the motion. @@ -496,31 +581,22 @@ public final class MotionEvent extends InputEvent implements Parcelable { static public MotionEvent obtain(long downTime, long eventTime, int action, float x, float y, float pressure, float size, int metaState, float xPrecision, float yPrecision, int deviceId, int edgeFlags) { - MotionEvent ev = obtain(1, 1); - ev.mDeviceId = deviceId; - ev.mSource = InputDevice.SOURCE_UNKNOWN; - ev.mEdgeFlags = edgeFlags; - ev.mDownTimeNano = downTime * MS_PER_NS; - ev.mAction = action; - ev.mFlags = 0; - ev.mMetaState = metaState; - ev.mXOffset = 0; - ev.mYOffset = 0; - ev.mXPrecision = xPrecision; - ev.mYPrecision = yPrecision; - - ev.mNumPointers = 1; - ev.mNumSamples = 1; - - ev.mLastDataSampleIndex = 0; - ev.mLastEventTimeNanoSampleIndex = 0; - - ev.mPointerIdentifiers[0] = 0; - - ev.mEventTimeNanoSamples[0] = eventTime * MS_PER_NS; - - ev.setPointerCoordsAtSampleIndex(0, x, y, pressure, size); - return ev; + synchronized (gTmpPointerCoords) { + final PointerCoords pc = gTmpPointerCoords[0]; + pc.clear(); + pc.x = x; + pc.y = y; + pc.pressure = pressure; + pc.size = size; + + MotionEvent ev = obtain(); + ev.mNativePtr = nativeInitialize(ev.mNativePtr, + deviceId, InputDevice.SOURCE_UNKNOWN, action, 0, edgeFlags, metaState, + 0, 0, xPrecision, yPrecision, + downTime * NS_PER_MS, eventTime * NS_PER_MS, + 1, gTmpPointerIds, gTmpPointerCoords); + return ev; + } } /** @@ -592,31 +668,13 @@ public final class MotionEvent extends InputEvent implements Parcelable { /** * Create a new MotionEvent, copying from an existing one. */ - static public MotionEvent obtain(MotionEvent o) { - MotionEvent ev = obtain(o.mNumPointers, o.mNumSamples); - ev.mDeviceId = o.mDeviceId; - ev.mSource = o.mSource; - ev.mEdgeFlags = o.mEdgeFlags; - ev.mDownTimeNano = o.mDownTimeNano; - ev.mAction = o.mAction; - ev.mFlags = o.mFlags; - ev.mMetaState = o.mMetaState; - ev.mXOffset = o.mXOffset; - ev.mYOffset = o.mYOffset; - ev.mXPrecision = o.mXPrecision; - ev.mYPrecision = o.mYPrecision; - int numPointers = ev.mNumPointers = o.mNumPointers; - int numSamples = ev.mNumSamples = o.mNumSamples; - - ev.mLastDataSampleIndex = o.mLastDataSampleIndex; - ev.mLastEventTimeNanoSampleIndex = o.mLastEventTimeNanoSampleIndex; - - System.arraycopy(o.mPointerIdentifiers, 0, ev.mPointerIdentifiers, 0, numPointers); - - System.arraycopy(o.mEventTimeNanoSamples, 0, ev.mEventTimeNanoSamples, 0, numSamples); - - System.arraycopy(o.mDataSamples, 0, ev.mDataSamples, 0, - numPointers * numSamples * NUM_SAMPLE_DATA); + static public MotionEvent obtain(MotionEvent other) { + if (other == null) { + throw new IllegalArgumentException("other motion event must not be null"); + } + + MotionEvent ev = obtain(); + ev.mNativePtr = nativeCopy(ev.mNativePtr, other.mNativePtr, true /*keepHistory*/); return ev; } @@ -624,32 +682,13 @@ public final class MotionEvent extends InputEvent implements Parcelable { * Create a new MotionEvent, copying from an existing one, but not including * any historical point information. */ - static public MotionEvent obtainNoHistory(MotionEvent o) { - MotionEvent ev = obtain(o.mNumPointers, 1); - ev.mDeviceId = o.mDeviceId; - ev.mSource = o.mSource; - ev.mEdgeFlags = o.mEdgeFlags; - ev.mDownTimeNano = o.mDownTimeNano; - ev.mAction = o.mAction; - o.mFlags = o.mFlags; - ev.mMetaState = o.mMetaState; - ev.mXOffset = o.mXOffset; - ev.mYOffset = o.mYOffset; - ev.mXPrecision = o.mXPrecision; - ev.mYPrecision = o.mYPrecision; - - int numPointers = ev.mNumPointers = o.mNumPointers; - ev.mNumSamples = 1; - - ev.mLastDataSampleIndex = 0; - ev.mLastEventTimeNanoSampleIndex = 0; - - System.arraycopy(o.mPointerIdentifiers, 0, ev.mPointerIdentifiers, 0, numPointers); - - ev.mEventTimeNanoSamples[0] = o.mEventTimeNanoSamples[o.mLastEventTimeNanoSampleIndex]; - - System.arraycopy(o.mDataSamples, o.mLastDataSampleIndex, ev.mDataSamples, 0, - numPointers * NUM_SAMPLE_DATA); + static public MotionEvent obtainNoHistory(MotionEvent other) { + if (other == null) { + throw new IllegalArgumentException("other motion event must not be null"); + } + + MotionEvent ev = obtain(); + ev.mNativePtr = nativeCopy(ev.mNativePtr, other.mNativePtr, false /*keepHistory*/); return ev; } @@ -675,7 +714,6 @@ public final class MotionEvent extends InputEvent implements Parcelable { synchronized (gRecyclerLock) { if (gRecyclerUsed < MAX_RECYCLED) { gRecyclerUsed++; - mNumSamples = 0; mNext = gRecyclerTop; gRecyclerTop = this; } @@ -688,23 +726,25 @@ public final class MotionEvent extends InputEvent implements Parcelable { * @hide */ public final void scale(float scale) { - mXOffset *= scale; - mYOffset *= scale; - mXPrecision *= scale; - mYPrecision *= scale; - - float[] history = mDataSamples; - final int length = mNumPointers * mNumSamples * NUM_SAMPLE_DATA; - for (int i = 0; i < length; i += NUM_SAMPLE_DATA) { - history[i + SAMPLE_X] *= scale; - history[i + SAMPLE_Y] *= scale; - // no need to scale pressure - history[i + SAMPLE_SIZE] *= scale; // TODO: square this? - history[i + SAMPLE_TOUCH_MAJOR] *= scale; - history[i + SAMPLE_TOUCH_MINOR] *= scale; - history[i + SAMPLE_TOOL_MAJOR] *= scale; - history[i + SAMPLE_TOOL_MINOR] *= scale; - } + nativeScale(mNativePtr, scale); + } + + /** {@inheritDoc} */ + @Override + public final int getDeviceId() { + return nativeGetDeviceId(mNativePtr); + } + + /** {@inheritDoc} */ + @Override + public final int getSource() { + return nativeGetSource(mNativePtr); + } + + /** {@inheritDoc} */ + @Override + public final void setSource(int source) { + nativeSetSource(mNativePtr, source); } /** @@ -715,7 +755,7 @@ public final class MotionEvent extends InputEvent implements Parcelable { * and pointer index. */ public final int getAction() { - return mAction; + return nativeGetAction(mNativePtr); } /** @@ -727,7 +767,7 @@ public final class MotionEvent extends InputEvent implements Parcelable { * pointer actions. */ public final int getActionMasked() { - return mAction & ACTION_MASK; + return nativeGetAction(mNativePtr) & ACTION_MASK; } /** @@ -739,7 +779,8 @@ public final class MotionEvent extends InputEvent implements Parcelable { * gone down or up. */ public final int getActionIndex() { - return (mAction & ACTION_POINTER_INDEX_MASK) >> ACTION_POINTER_INDEX_SHIFT; + return (nativeGetAction(mNativePtr) & ACTION_POINTER_INDEX_MASK) + >> ACTION_POINTER_INDEX_SHIFT; } /** @@ -748,7 +789,7 @@ public final class MotionEvent extends InputEvent implements Parcelable { * @see #FLAG_WINDOW_IS_OBSCURED */ public final int getFlags() { - return mFlags; + return nativeGetFlags(mNativePtr); } /** @@ -756,14 +797,14 @@ public final class MotionEvent extends InputEvent implements Parcelable { * a stream of position events. */ public final long getDownTime() { - return mDownTimeNano / MS_PER_NS; + return nativeGetDownTimeNanos(mNativePtr) / NS_PER_MS; } /** * Returns the time (in ms) when this specific event was generated. */ public final long getEventTime() { - return mEventTimeNanoSamples[mLastEventTimeNanoSampleIndex] / MS_PER_NS; + return nativeGetEventTimeNanos(mNativePtr, HISTORY_CURRENT) / NS_PER_MS; } /** @@ -773,79 +814,110 @@ public final class MotionEvent extends InputEvent implements Parcelable { * @hide */ public final long getEventTimeNano() { - return mEventTimeNanoSamples[mLastEventTimeNanoSampleIndex]; + return nativeGetEventTimeNanos(mNativePtr, HISTORY_CURRENT); } /** * {@link #getX(int)} for the first pointer index (may be an * arbitrary pointer identifier). + * + * @see #AXIS_X */ public final float getX() { - return mDataSamples[mLastDataSampleIndex + SAMPLE_X] + mXOffset; + return nativeGetAxisValue(mNativePtr, AXIS_X, 0, HISTORY_CURRENT); } /** * {@link #getY(int)} for the first pointer index (may be an * arbitrary pointer identifier). + * + * @see #AXIS_Y */ public final float getY() { - return mDataSamples[mLastDataSampleIndex + SAMPLE_Y] + mYOffset; + return nativeGetAxisValue(mNativePtr, AXIS_Y, 0, HISTORY_CURRENT); } /** * {@link #getPressure(int)} for the first pointer index (may be an * arbitrary pointer identifier). + * + * @see #AXIS_PRESSURE */ public final float getPressure() { - return mDataSamples[mLastDataSampleIndex + SAMPLE_PRESSURE]; + return nativeGetAxisValue(mNativePtr, AXIS_PRESSURE, 0, HISTORY_CURRENT); } /** * {@link #getSize(int)} for the first pointer index (may be an * arbitrary pointer identifier). + * + * @see #AXIS_SIZE */ public final float getSize() { - return mDataSamples[mLastDataSampleIndex + SAMPLE_SIZE]; + return nativeGetAxisValue(mNativePtr, AXIS_SIZE, 0, HISTORY_CURRENT); } /** * {@link #getTouchMajor(int)} for the first pointer index (may be an * arbitrary pointer identifier). + * + * @see #AXIS_TOUCH_MAJOR */ public final float getTouchMajor() { - return mDataSamples[mLastDataSampleIndex + SAMPLE_TOUCH_MAJOR]; + return nativeGetAxisValue(mNativePtr, AXIS_TOUCH_MAJOR, 0, HISTORY_CURRENT); } /** * {@link #getTouchMinor(int)} for the first pointer index (may be an * arbitrary pointer identifier). + * + * @see #AXIS_TOUCH_MINOR */ public final float getTouchMinor() { - return mDataSamples[mLastDataSampleIndex + SAMPLE_TOUCH_MINOR]; + return nativeGetAxisValue(mNativePtr, AXIS_TOUCH_MINOR, 0, HISTORY_CURRENT); } /** * {@link #getToolMajor(int)} for the first pointer index (may be an * arbitrary pointer identifier). + * + * @see #AXIS_TOOL_MAJOR */ public final float getToolMajor() { - return mDataSamples[mLastDataSampleIndex + SAMPLE_TOOL_MAJOR]; + return nativeGetAxisValue(mNativePtr, AXIS_TOOL_MAJOR, 0, HISTORY_CURRENT); } /** * {@link #getToolMinor(int)} for the first pointer index (may be an * arbitrary pointer identifier). + * + * @see #AXIS_TOOL_MINOR */ public final float getToolMinor() { - return mDataSamples[mLastDataSampleIndex + SAMPLE_TOOL_MINOR]; + return nativeGetAxisValue(mNativePtr, AXIS_TOOL_MINOR, 0, HISTORY_CURRENT); } - + /** * {@link #getOrientation(int)} for the first pointer index (may be an * arbitrary pointer identifier). + * + * @see #AXIS_ORIENTATION */ public final float getOrientation() { - return mDataSamples[mLastDataSampleIndex + SAMPLE_ORIENTATION]; + return nativeGetAxisValue(mNativePtr, AXIS_ORIENTATION, 0, HISTORY_CURRENT); + } + + /** + * {@link #getAxisValue(int)} for the first pointer index (may be an + * arbitrary pointer identifier). + * + * @param axis The axis identifier for the axis value to retrieve. + * + * @see #AXIS_X + * @see #AXIS_Y + */ + public final float getAxisValue(int axis) { + return nativeGetAxisValue(mNativePtr, axis, 0, HISTORY_CURRENT); } /** @@ -853,7 +925,7 @@ public final class MotionEvent extends InputEvent implements Parcelable { * >= 1. */ public final int getPointerCount() { - return mNumPointers; + return nativeGetPointerCount(mNativePtr); } /** @@ -865,7 +937,7 @@ public final class MotionEvent extends InputEvent implements Parcelable { * (the first pointer that is down) to {@link #getPointerCount()}-1. */ public final int getPointerId(int pointerIndex) { - return mPointerIdentifiers[pointerIndex]; + return nativeGetPointerId(mNativePtr, pointerIndex); } /** @@ -877,14 +949,7 @@ public final class MotionEvent extends InputEvent implements Parcelable { * that pointer identifier. */ public final int findPointerIndex(int pointerId) { - int i = mNumPointers; - while (i > 0) { - i--; - if (mPointerIdentifiers[i] == pointerId) { - return i; - } - } - return -1; + return nativeFindPointerIndex(mNativePtr, pointerId); } /** @@ -895,10 +960,11 @@ public final class MotionEvent extends InputEvent implements Parcelable { * value may have a fraction for input devices that are sub-pixel precise. * @param pointerIndex Raw index of pointer to retrieve. Value may be from 0 * (the first pointer that is down) to {@link #getPointerCount()}-1. + * + * @see #AXIS_X */ public final float getX(int pointerIndex) { - return mDataSamples[mLastDataSampleIndex - + pointerIndex * NUM_SAMPLE_DATA + SAMPLE_X] + mXOffset; + return nativeGetAxisValue(mNativePtr, AXIS_X, pointerIndex, HISTORY_CURRENT); } /** @@ -909,10 +975,11 @@ public final class MotionEvent extends InputEvent implements Parcelable { * value may have a fraction for input devices that are sub-pixel precise. * @param pointerIndex Raw index of pointer to retrieve. Value may be from 0 * (the first pointer that is down) to {@link #getPointerCount()}-1. + * + * @see #AXIS_Y */ public final float getY(int pointerIndex) { - return mDataSamples[mLastDataSampleIndex - + pointerIndex * NUM_SAMPLE_DATA + SAMPLE_Y] + mYOffset; + return nativeGetAxisValue(mNativePtr, AXIS_Y, pointerIndex, HISTORY_CURRENT); } /** @@ -925,10 +992,11 @@ public final class MotionEvent extends InputEvent implements Parcelable { * the input device. * @param pointerIndex Raw index of pointer to retrieve. Value may be from 0 * (the first pointer that is down) to {@link #getPointerCount()}-1. + * + * @see #AXIS_PRESSURE */ public final float getPressure(int pointerIndex) { - return mDataSamples[mLastDataSampleIndex - + pointerIndex * NUM_SAMPLE_DATA + SAMPLE_PRESSURE]; + return nativeGetAxisValue(mNativePtr, AXIS_PRESSURE, pointerIndex, HISTORY_CURRENT); } /** @@ -942,10 +1010,11 @@ public final class MotionEvent extends InputEvent implements Parcelable { * determine fat touch events. * @param pointerIndex Raw index of pointer to retrieve. Value may be from 0 * (the first pointer that is down) to {@link #getPointerCount()}-1. + * + * @see #AXIS_SIZE */ public final float getSize(int pointerIndex) { - return mDataSamples[mLastDataSampleIndex - + pointerIndex * NUM_SAMPLE_DATA + SAMPLE_SIZE]; + return nativeGetAxisValue(mNativePtr, AXIS_SIZE, pointerIndex, HISTORY_CURRENT); } /** @@ -955,10 +1024,11 @@ public final class MotionEvent extends InputEvent implements Parcelable { * identifier for this index). * @param pointerIndex Raw index of pointer to retrieve. Value may be from 0 * (the first pointer that is down) to {@link #getPointerCount()}-1. + * + * @see #AXIS_TOUCH_MAJOR */ public final float getTouchMajor(int pointerIndex) { - return mDataSamples[mLastDataSampleIndex - + pointerIndex * NUM_SAMPLE_DATA + SAMPLE_TOUCH_MAJOR]; + return nativeGetAxisValue(mNativePtr, AXIS_TOUCH_MAJOR, pointerIndex, HISTORY_CURRENT); } /** @@ -968,10 +1038,11 @@ public final class MotionEvent extends InputEvent implements Parcelable { * identifier for this index). * @param pointerIndex Raw index of pointer to retrieve. Value may be from 0 * (the first pointer that is down) to {@link #getPointerCount()}-1. + * + * @see #AXIS_TOUCH_MINOR */ public final float getTouchMinor(int pointerIndex) { - return mDataSamples[mLastDataSampleIndex - + pointerIndex * NUM_SAMPLE_DATA + SAMPLE_TOUCH_MINOR]; + return nativeGetAxisValue(mNativePtr, AXIS_TOUCH_MINOR, pointerIndex, HISTORY_CURRENT); } /** @@ -983,10 +1054,11 @@ public final class MotionEvent extends InputEvent implements Parcelable { * touching the device independent of its actual touch area at the point of contact. * @param pointerIndex Raw index of pointer to retrieve. Value may be from 0 * (the first pointer that is down) to {@link #getPointerCount()}-1. + * + * @see #AXIS_TOOL_MAJOR */ public final float getToolMajor(int pointerIndex) { - return mDataSamples[mLastDataSampleIndex - + pointerIndex * NUM_SAMPLE_DATA + SAMPLE_TOOL_MAJOR]; + return nativeGetAxisValue(mNativePtr, AXIS_TOOL_MAJOR, pointerIndex, HISTORY_CURRENT); } /** @@ -998,10 +1070,11 @@ public final class MotionEvent extends InputEvent implements Parcelable { * touching the device independent of its actual touch area at the point of contact. * @param pointerIndex Raw index of pointer to retrieve. Value may be from 0 * (the first pointer that is down) to {@link #getPointerCount()}-1. + * + * @see #AXIS_TOOL_MINOR */ public final float getToolMinor(int pointerIndex) { - return mDataSamples[mLastDataSampleIndex - + pointerIndex * NUM_SAMPLE_DATA + SAMPLE_TOOL_MINOR]; + return nativeGetAxisValue(mNativePtr, AXIS_TOOL_MINOR, pointerIndex, HISTORY_CURRENT); } /** @@ -1016,12 +1089,29 @@ public final class MotionEvent extends InputEvent implements Parcelable { * (finger pointing fully right). * @param pointerIndex Raw index of pointer to retrieve. Value may be from 0 * (the first pointer that is down) to {@link #getPointerCount()}-1. + * + * @see #AXIS_ORIENTATION */ public final float getOrientation(int pointerIndex) { - return mDataSamples[mLastDataSampleIndex - + pointerIndex * NUM_SAMPLE_DATA + SAMPLE_ORIENTATION]; + return nativeGetAxisValue(mNativePtr, AXIS_ORIENTATION, pointerIndex, HISTORY_CURRENT); } - + + /** + * Returns the value of the requested axis for the given pointer <em>index</em> + * (use {@link #getPointerId(int)} to find the pointer identifier for this index). + * + * @param axis The axis identifier for the axis value to retrieve. + * @param pointerIndex Raw index of pointer to retrieve. Value may be from 0 + * (the first pointer that is down) to {@link #getPointerCount()}-1. + * @return The value of the axis, or 0 if the axis is not available. + * + * @see #AXIS_X + * @see #AXIS_Y + */ + public final float getAxisValue(int axis, int pointerIndex) { + return nativeGetAxisValue(mNativePtr, axis, pointerIndex, HISTORY_CURRENT); + } + /** * Populates a {@link PointerCoords} object with pointer coordinate data for * the specified pointer index. @@ -1029,10 +1119,11 @@ public final class MotionEvent extends InputEvent implements Parcelable { * @param pointerIndex Raw index of pointer to retrieve. Value may be from 0 * (the first pointer that is down) to {@link #getPointerCount()}-1. * @param outPointerCoords The pointer coordinate object to populate. + * + * @see PointerCoords */ public final void getPointerCoords(int pointerIndex, PointerCoords outPointerCoords) { - final int sampleIndex = mLastDataSampleIndex + pointerIndex * NUM_SAMPLE_DATA; - getPointerCoordsAtSampleIndex(sampleIndex, outPointerCoords); + nativeGetPointerCoords(mNativePtr, pointerIndex, HISTORY_CURRENT, outPointerCoords); } /** @@ -1046,7 +1137,7 @@ public final class MotionEvent extends InputEvent implements Parcelable { * @see KeyEvent#getMetaState() */ public final int getMetaState() { - return mMetaState; + return nativeGetMetaState(mNativePtr); } /** @@ -1054,39 +1145,49 @@ public final class MotionEvent extends InputEvent implements Parcelable { * events on the screen, this is the original location of the event * on the screen, before it had been adjusted for the containing window * and views. + * + * @see getX() + * @see #AXIS_X */ public final float getRawX() { - return mDataSamples[mLastDataSampleIndex + SAMPLE_X]; + return nativeGetRawAxisValue(mNativePtr, AXIS_X, 0, HISTORY_CURRENT); } - + /** * Returns the original raw Y coordinate of this event. For touch * events on the screen, this is the original location of the event * on the screen, before it had been adjusted for the containing window * and views. + * + * @see getY() + * @see #AXIS_Y */ public final float getRawY() { - return mDataSamples[mLastDataSampleIndex + SAMPLE_Y]; + return nativeGetRawAxisValue(mNativePtr, AXIS_Y, 0, HISTORY_CURRENT); } /** * Return the precision of the X coordinates being reported. You can - * multiple this number with {@link #getX} to find the actual hardware + * multiply this number with {@link #getX} to find the actual hardware * value of the X coordinate. * @return Returns the precision of X coordinates being reported. + * + * @see #AXIS_X */ public final float getXPrecision() { - return mXPrecision; + return nativeGetXPrecision(mNativePtr); } /** * Return the precision of the Y coordinates being reported. You can - * multiple this number with {@link #getY} to find the actual hardware + * multiply this number with {@link #getY} to find the actual hardware * value of the Y coordinate. * @return Returns the precision of Y coordinates being reported. + * + * @see #AXIS_Y */ public final float getYPrecision() { - return mYPrecision; + return nativeGetYPrecision(mNativePtr); } /** @@ -1098,7 +1199,7 @@ public final class MotionEvent extends InputEvent implements Parcelable { * @return Returns the number of historical points in the event. */ public final int getHistorySize() { - return mLastEventTimeNanoSampleIndex; + return nativeGetHistorySize(mNativePtr); } /** @@ -1112,81 +1213,161 @@ public final class MotionEvent extends InputEvent implements Parcelable { * @see #getEventTime */ public final long getHistoricalEventTime(int pos) { - return mEventTimeNanoSamples[pos] / MS_PER_NS; + return nativeGetEventTimeNanos(mNativePtr, pos) / NS_PER_MS; } /** - * {@link #getHistoricalX(int)} for the first pointer index (may be an + * {@link #getHistoricalX(int, int)} for the first pointer index (may be an * arbitrary pointer identifier). + * + * @param pos Which historical value to return; must be less than + * {@link #getHistorySize} + * + * @see #getHistorySize + * @see #getX() + * @see #AXIS_X */ public final float getHistoricalX(int pos) { - return mDataSamples[pos * mNumPointers * NUM_SAMPLE_DATA + SAMPLE_X] + mXOffset; + return nativeGetAxisValue(mNativePtr, AXIS_X, 0, pos); } /** - * {@link #getHistoricalY(int)} for the first pointer index (may be an + * {@link #getHistoricalY(int, int)} for the first pointer index (may be an * arbitrary pointer identifier). + * + * @param pos Which historical value to return; must be less than + * {@link #getHistorySize} + * + * @see #getHistorySize + * @see #getY() + * @see #AXIS_Y */ public final float getHistoricalY(int pos) { - return mDataSamples[pos * mNumPointers * NUM_SAMPLE_DATA + SAMPLE_Y] + mYOffset; + return nativeGetAxisValue(mNativePtr, AXIS_Y, 0, pos); } /** - * {@link #getHistoricalPressure(int)} for the first pointer index (may be an + * {@link #getHistoricalPressure(int, int)} for the first pointer index (may be an * arbitrary pointer identifier). + * + * @param pos Which historical value to return; must be less than + * {@link #getHistorySize} + * + * @see #getHistorySize + * @see #getPressure() + * @see #AXIS_PRESSURE */ public final float getHistoricalPressure(int pos) { - return mDataSamples[pos * mNumPointers * NUM_SAMPLE_DATA + SAMPLE_PRESSURE]; + return nativeGetAxisValue(mNativePtr, AXIS_PRESSURE, 0, pos); } /** - * {@link #getHistoricalSize(int)} for the first pointer index (may be an + * {@link #getHistoricalSize(int, int)} for the first pointer index (may be an * arbitrary pointer identifier). + * + * @param pos Which historical value to return; must be less than + * {@link #getHistorySize} + * + * @see #getHistorySize + * @see #getSize() + * @see #AXIS_SIZE */ public final float getHistoricalSize(int pos) { - return mDataSamples[pos * mNumPointers * NUM_SAMPLE_DATA + SAMPLE_SIZE]; + return nativeGetAxisValue(mNativePtr, AXIS_SIZE, 0, pos); } /** - * {@link #getHistoricalTouchMajor(int)} for the first pointer index (may be an + * {@link #getHistoricalTouchMajor(int, int)} for the first pointer index (may be an * arbitrary pointer identifier). + * + * @param pos Which historical value to return; must be less than + * {@link #getHistorySize} + * + * @see #getHistorySize + * @see #getTouchMajor() + * @see #AXIS_TOUCH_MAJOR */ public final float getHistoricalTouchMajor(int pos) { - return mDataSamples[pos * mNumPointers * NUM_SAMPLE_DATA + SAMPLE_TOUCH_MAJOR]; + return nativeGetAxisValue(mNativePtr, AXIS_TOUCH_MAJOR, 0, pos); } /** - * {@link #getHistoricalTouchMinor(int)} for the first pointer index (may be an + * {@link #getHistoricalTouchMinor(int, int)} for the first pointer index (may be an * arbitrary pointer identifier). + * + * @param pos Which historical value to return; must be less than + * {@link #getHistorySize} + * + * @see #getHistorySize + * @see #getTouchMinor() + * @see #AXIS_TOUCH_MINOR */ public final float getHistoricalTouchMinor(int pos) { - return mDataSamples[pos * mNumPointers * NUM_SAMPLE_DATA + SAMPLE_TOUCH_MINOR]; + return nativeGetAxisValue(mNativePtr, AXIS_TOUCH_MINOR, 0, pos); } /** - * {@link #getHistoricalToolMajor(int)} for the first pointer index (may be an + * {@link #getHistoricalToolMajor(int, int)} for the first pointer index (may be an * arbitrary pointer identifier). + * + * @param pos Which historical value to return; must be less than + * {@link #getHistorySize} + * + * @see #getHistorySize + * @see #getToolMajor() + * @see #AXIS_TOOL_MAJOR */ public final float getHistoricalToolMajor(int pos) { - return mDataSamples[pos * mNumPointers * NUM_SAMPLE_DATA + SAMPLE_TOOL_MAJOR]; + return nativeGetAxisValue(mNativePtr, AXIS_TOOL_MAJOR, 0, pos); } /** - * {@link #getHistoricalToolMinor(int)} for the first pointer index (may be an + * {@link #getHistoricalToolMinor(int, int)} for the first pointer index (may be an * arbitrary pointer identifier). + * + * @param pos Which historical value to return; must be less than + * {@link #getHistorySize} + * + * @see #getHistorySize + * @see #getToolMinor() + * @see #AXIS_TOOL_MINOR */ public final float getHistoricalToolMinor(int pos) { - return mDataSamples[pos * mNumPointers * NUM_SAMPLE_DATA + SAMPLE_TOOL_MINOR]; + return nativeGetAxisValue(mNativePtr, AXIS_TOOL_MINOR, 0, pos); } /** - * {@link #getHistoricalOrientation(int)} for the first pointer index (may be an + * {@link #getHistoricalOrientation(int, int)} for the first pointer index (may be an * arbitrary pointer identifier). + * + * @param pos Which historical value to return; must be less than + * {@link #getHistorySize} + * + * @see #getHistorySize + * @see #getOrientation() + * @see #AXIS_ORIENTATION */ public final float getHistoricalOrientation(int pos) { - return mDataSamples[pos * mNumPointers * NUM_SAMPLE_DATA + SAMPLE_ORIENTATION]; + return nativeGetAxisValue(mNativePtr, AXIS_ORIENTATION, 0, pos); } - + + /** + * {@link #getHistoricalAxisValue(int, int, int)} for the first pointer index (may be an + * arbitrary pointer identifier). + * + * @param axis The axis identifier for the axis value to retrieve. + * @param pos Which historical value to return; must be less than + * {@link #getHistorySize} + * + * @see #getHistorySize + * @see #getAxisValue(int) + * @see #AXIS_X + * @see #AXIS_Y + */ + public final float getHistoricalAxisValue(int axis, int pos) { + return nativeGetAxisValue(mNativePtr, axis, 0, pos); + } + /** * Returns a historical X coordinate, as per {@link #getX(int)}, that * occurred between this event and the previous event for the given pointer. @@ -1198,11 +1379,11 @@ public final class MotionEvent extends InputEvent implements Parcelable { * {@link #getHistorySize} * * @see #getHistorySize - * @see #getX + * @see #getX(int) + * @see #AXIS_X */ public final float getHistoricalX(int pointerIndex, int pos) { - return mDataSamples[(pos * mNumPointers + pointerIndex) - * NUM_SAMPLE_DATA + SAMPLE_X] + mXOffset; + return nativeGetAxisValue(mNativePtr, AXIS_X, pointerIndex, pos); } /** @@ -1216,11 +1397,11 @@ public final class MotionEvent extends InputEvent implements Parcelable { * {@link #getHistorySize} * * @see #getHistorySize - * @see #getY + * @see #getY(int) + * @see #AXIS_Y */ public final float getHistoricalY(int pointerIndex, int pos) { - return mDataSamples[(pos * mNumPointers + pointerIndex) - * NUM_SAMPLE_DATA + SAMPLE_Y] + mYOffset; + return nativeGetAxisValue(mNativePtr, AXIS_Y, pointerIndex, pos); } /** @@ -1234,11 +1415,11 @@ public final class MotionEvent extends InputEvent implements Parcelable { * {@link #getHistorySize} * * @see #getHistorySize - * @see #getPressure + * @see #getPressure(int) + * @see #AXIS_PRESSURE */ public final float getHistoricalPressure(int pointerIndex, int pos) { - return mDataSamples[(pos * mNumPointers + pointerIndex) - * NUM_SAMPLE_DATA + SAMPLE_PRESSURE]; + return nativeGetAxisValue(mNativePtr, AXIS_PRESSURE, pointerIndex, pos); } /** @@ -1252,11 +1433,11 @@ public final class MotionEvent extends InputEvent implements Parcelable { * {@link #getHistorySize} * * @see #getHistorySize - * @see #getSize + * @see #getSize(int) + * @see #AXIS_SIZE */ public final float getHistoricalSize(int pointerIndex, int pos) { - return mDataSamples[(pos * mNumPointers + pointerIndex) - * NUM_SAMPLE_DATA + SAMPLE_SIZE]; + return nativeGetAxisValue(mNativePtr, AXIS_SIZE, pointerIndex, pos); } /** @@ -1270,11 +1451,11 @@ public final class MotionEvent extends InputEvent implements Parcelable { * {@link #getHistorySize} * * @see #getHistorySize - * @see #getTouchMajor + * @see #getTouchMajor(int) + * @see #AXIS_TOUCH_MAJOR */ public final float getHistoricalTouchMajor(int pointerIndex, int pos) { - return mDataSamples[(pos * mNumPointers + pointerIndex) - * NUM_SAMPLE_DATA + SAMPLE_TOUCH_MAJOR]; + return nativeGetAxisValue(mNativePtr, AXIS_TOUCH_MAJOR, pointerIndex, pos); } /** @@ -1288,11 +1469,11 @@ public final class MotionEvent extends InputEvent implements Parcelable { * {@link #getHistorySize} * * @see #getHistorySize - * @see #getTouchMinor + * @see #getTouchMinor(int) + * @see #AXIS_TOUCH_MINOR */ public final float getHistoricalTouchMinor(int pointerIndex, int pos) { - return mDataSamples[(pos * mNumPointers + pointerIndex) - * NUM_SAMPLE_DATA + SAMPLE_TOUCH_MINOR]; + return nativeGetAxisValue(mNativePtr, AXIS_TOUCH_MINOR, pointerIndex, pos); } /** @@ -1306,11 +1487,11 @@ public final class MotionEvent extends InputEvent implements Parcelable { * {@link #getHistorySize} * * @see #getHistorySize - * @see #getToolMajor + * @see #getToolMajor(int) + * @see #AXIS_TOOL_MAJOR */ public final float getHistoricalToolMajor(int pointerIndex, int pos) { - return mDataSamples[(pos * mNumPointers + pointerIndex) - * NUM_SAMPLE_DATA + SAMPLE_TOOL_MAJOR]; + return nativeGetAxisValue(mNativePtr, AXIS_TOOL_MAJOR, pointerIndex, pos); } /** @@ -1324,11 +1505,11 @@ public final class MotionEvent extends InputEvent implements Parcelable { * {@link #getHistorySize} * * @see #getHistorySize - * @see #getToolMinor + * @see #getToolMinor(int) + * @see #AXIS_TOOL_MINOR */ public final float getHistoricalToolMinor(int pointerIndex, int pos) { - return mDataSamples[(pos * mNumPointers + pointerIndex) - * NUM_SAMPLE_DATA + SAMPLE_TOOL_MINOR]; + return nativeGetAxisValue(mNativePtr, AXIS_TOOL_MINOR, pointerIndex, pos); } /** @@ -1342,11 +1523,30 @@ public final class MotionEvent extends InputEvent implements Parcelable { * {@link #getHistorySize} * * @see #getHistorySize - * @see #getOrientation + * @see #getOrientation(int) + * @see #AXIS_ORIENTATION */ public final float getHistoricalOrientation(int pointerIndex, int pos) { - return mDataSamples[(pos * mNumPointers + pointerIndex) - * NUM_SAMPLE_DATA + SAMPLE_ORIENTATION]; + return nativeGetAxisValue(mNativePtr, AXIS_ORIENTATION, pointerIndex, pos); + } + + /** + * Returns the historical value of the requested axis, as per {@link #getAxisValue(int, int)}, + * occurred between this event and the previous event for the given pointer. + * Only applies to ACTION_MOVE events. + * + * @param axis The axis identifier for the axis value to retrieve. + * @param pointerIndex Raw index of pointer to retrieve. Value may be from 0 + * (the first pointer that is down) to {@link #getPointerCount()}-1. + * @param pos Which historical value to return; must be less than + * {@link #getHistorySize} + * @return The value of the axis, or 0 if the axis is not available. + * + * @see #AXIS_X + * @see #AXIS_Y + */ + public final float getHistoricalAxisValue(int axis, int pointerIndex, int pos) { + return nativeGetAxisValue(mNativePtr, axis, pointerIndex, pos); } /** @@ -1363,11 +1563,11 @@ public final class MotionEvent extends InputEvent implements Parcelable { * * @see #getHistorySize * @see #getPointerCoords + * @see PointerCoords */ public final void getHistoricalPointerCoords(int pointerIndex, int pos, PointerCoords outPointerCoords) { - final int sampleIndex = (pos * mNumPointers + pointerIndex) * NUM_SAMPLE_DATA; - getPointerCoordsAtSampleIndex(sampleIndex, outPointerCoords); + nativeGetPointerCoords(mNativePtr, pointerIndex, pos, outPointerCoords); } /** @@ -1381,10 +1581,9 @@ public final class MotionEvent extends InputEvent implements Parcelable { * @see #EDGE_BOTTOM */ public final int getEdgeFlags() { - return mEdgeFlags; + return nativeGetEdgeFlags(mNativePtr); } - /** * Sets the bitfield indicating which edges, if any, were touched by this * MotionEvent. @@ -1392,14 +1591,14 @@ public final class MotionEvent extends InputEvent implements Parcelable { * @see #getEdgeFlags() */ public final void setEdgeFlags(int flags) { - mEdgeFlags = flags; + nativeSetEdgeFlags(mNativePtr, flags); } /** * Sets this event's action. */ public final void setAction(int action) { - mAction = action; + nativeSetAction(mNativePtr, action); } /** @@ -1408,8 +1607,7 @@ public final class MotionEvent extends InputEvent implements Parcelable { * @param deltaY Amount to add to the current Y coordinate of the event. */ public final void offsetLocation(float deltaX, float deltaY) { - mXOffset += deltaX; - mYOffset += deltaY; + nativeOffsetLocation(mNativePtr, deltaX, deltaY); } /** @@ -1420,10 +1618,9 @@ public final class MotionEvent extends InputEvent implements Parcelable { * @param y New absolute Y location. */ public final void setLocation(float x, float y) { - final float[] dataSamples = mDataSamples; - final int lastDataSampleIndex = mLastDataSampleIndex; - mXOffset = x - dataSamples[lastDataSampleIndex + SAMPLE_X]; - mYOffset = y - dataSamples[lastDataSampleIndex + SAMPLE_Y]; + float oldX = getX(); + float oldY = getY(); + nativeOffsetLocation(mNativePtr, x - oldX, y - oldY); } /** @@ -1436,85 +1633,14 @@ public final class MotionEvent extends InputEvent implements Parcelable { throw new IllegalArgumentException("matrix must not be null"); } - nativeTransform(matrix); - } - - private final void getPointerCoordsAtSampleIndex(int sampleIndex, - PointerCoords outPointerCoords) { - final float[] dataSamples = mDataSamples; - outPointerCoords.x = dataSamples[sampleIndex + SAMPLE_X] + mXOffset; - outPointerCoords.y = dataSamples[sampleIndex + SAMPLE_Y] + mYOffset; - outPointerCoords.pressure = dataSamples[sampleIndex + SAMPLE_PRESSURE]; - outPointerCoords.size = dataSamples[sampleIndex + SAMPLE_SIZE]; - outPointerCoords.touchMajor = dataSamples[sampleIndex + SAMPLE_TOUCH_MAJOR]; - outPointerCoords.touchMinor = dataSamples[sampleIndex + SAMPLE_TOUCH_MINOR]; - outPointerCoords.toolMajor = dataSamples[sampleIndex + SAMPLE_TOOL_MAJOR]; - outPointerCoords.toolMinor = dataSamples[sampleIndex + SAMPLE_TOOL_MINOR]; - outPointerCoords.orientation = dataSamples[sampleIndex + SAMPLE_ORIENTATION]; - } - - private final void setPointerCoordsAtSampleIndex(int sampleIndex, - PointerCoords[] pointerCoords) { - final int numPointers = mNumPointers; - for (int i = 0; i < numPointers; i++) { - setPointerCoordsAtSampleIndex(sampleIndex, pointerCoords[i]); - sampleIndex += NUM_SAMPLE_DATA; - } - } - - private final void setPointerCoordsAtSampleIndex(int sampleIndex, - PointerCoords pointerCoords) { - final float[] dataSamples = mDataSamples; - dataSamples[sampleIndex + SAMPLE_X] = pointerCoords.x - mXOffset; - dataSamples[sampleIndex + SAMPLE_Y] = pointerCoords.y - mYOffset; - dataSamples[sampleIndex + SAMPLE_PRESSURE] = pointerCoords.pressure; - dataSamples[sampleIndex + SAMPLE_SIZE] = pointerCoords.size; - dataSamples[sampleIndex + SAMPLE_TOUCH_MAJOR] = pointerCoords.touchMajor; - dataSamples[sampleIndex + SAMPLE_TOUCH_MINOR] = pointerCoords.touchMinor; - dataSamples[sampleIndex + SAMPLE_TOOL_MAJOR] = pointerCoords.toolMajor; - dataSamples[sampleIndex + SAMPLE_TOOL_MINOR] = pointerCoords.toolMinor; - dataSamples[sampleIndex + SAMPLE_ORIENTATION] = pointerCoords.orientation; - } - - private final void setPointerCoordsAtSampleIndex(int sampleIndex, - float x, float y, float pressure, float size) { - final float[] dataSamples = mDataSamples; - dataSamples[sampleIndex + SAMPLE_X] = x - mXOffset; - dataSamples[sampleIndex + SAMPLE_Y] = y - mYOffset; - dataSamples[sampleIndex + SAMPLE_PRESSURE] = pressure; - dataSamples[sampleIndex + SAMPLE_SIZE] = size; - dataSamples[sampleIndex + SAMPLE_TOUCH_MAJOR] = pressure; - dataSamples[sampleIndex + SAMPLE_TOUCH_MINOR] = pressure; - dataSamples[sampleIndex + SAMPLE_TOOL_MAJOR] = size; - dataSamples[sampleIndex + SAMPLE_TOOL_MINOR] = size; - dataSamples[sampleIndex + SAMPLE_ORIENTATION] = 0; - } - - private final void incrementNumSamplesAndReserveStorage(int dataSampleStride) { - if (mNumSamples == mEventTimeNanoSamples.length) { - long[] newEventTimeNanoSamples = new long[mNumSamples + BASE_AVAIL_SAMPLES]; - System.arraycopy(mEventTimeNanoSamples, 0, newEventTimeNanoSamples, 0, mNumSamples); - mEventTimeNanoSamples = newEventTimeNanoSamples; - } - - int nextDataSampleIndex = mLastDataSampleIndex + dataSampleStride; - if (nextDataSampleIndex + dataSampleStride > mDataSamples.length) { - float[] newDataSamples = new float[nextDataSampleIndex - + BASE_AVAIL_SAMPLES * dataSampleStride]; - System.arraycopy(mDataSamples, 0, newDataSamples, 0, nextDataSampleIndex); - mDataSamples = newDataSamples; - } - - mLastEventTimeNanoSampleIndex = mNumSamples; - mLastDataSampleIndex = nextDataSampleIndex; - mNumSamples += 1; + nativeTransform(mNativePtr, matrix); } /** * Add a new movement to the batch of movements in this event. The event's * current location, position and size is updated to the new values. * The current values in the event are added to a list of historical values. - * + * * Only applies to {@link #ACTION_MOVE} events. * * @param eventTime The time stamp (in ms) for this data. @@ -1526,19 +1652,22 @@ public final class MotionEvent extends InputEvent implements Parcelable { */ public final void addBatch(long eventTime, float x, float y, float pressure, float size, int metaState) { - incrementNumSamplesAndReserveStorage(NUM_SAMPLE_DATA); - - mEventTimeNanoSamples[mLastEventTimeNanoSampleIndex] = eventTime * MS_PER_NS; - setPointerCoordsAtSampleIndex(mLastDataSampleIndex, x, y, pressure, size); - - mMetaState |= metaState; + synchronized (gTmpPointerCoords) { + final PointerCoords pc = gTmpPointerCoords[0]; + pc.clear(); + pc.x = x; + pc.y = y; + pc.pressure = pressure; + pc.size = size; + nativeAddBatch(mNativePtr, eventTime * NS_PER_MS, gTmpPointerCoords, metaState); + } } /** * Add a new movement to the batch of movements in this event. The event's * current location, position and size is updated to the new values. * The current values in the event are added to a list of historical values. - * + * * Only applies to {@link #ACTION_MOVE} events. * * @param eventTime The time stamp (in ms) for this data. @@ -1546,20 +1675,14 @@ public final class MotionEvent extends InputEvent implements Parcelable { * @param metaState Meta key state. */ public final void addBatch(long eventTime, PointerCoords[] pointerCoords, int metaState) { - final int dataSampleStride = mNumPointers * NUM_SAMPLE_DATA; - incrementNumSamplesAndReserveStorage(dataSampleStride); - - mEventTimeNanoSamples[mLastEventTimeNanoSampleIndex] = eventTime * MS_PER_NS; - setPointerCoordsAtSampleIndex(mLastDataSampleIndex, pointerCoords); - - mMetaState |= metaState; + nativeAddBatch(mNativePtr, eventTime * NS_PER_MS, pointerCoords, metaState); } @Override public String toString() { return "MotionEvent{" + Integer.toHexString(System.identityHashCode(this)) + " pointerId=" + getPointerId(0) - + " action=" + actionToString(mAction) + + " action=" + actionToString(getAction()) + " x=" + getX() + " y=" + getY() + " pressure=" + getPressure() @@ -1569,13 +1692,13 @@ public final class MotionEvent extends InputEvent implements Parcelable { + " toolMajor=" + getToolMajor() + " toolMinor=" + getToolMinor() + " orientation=" + getOrientation() - + " meta=" + KeyEvent.metaStateToString(mMetaState) + + " meta=" + KeyEvent.metaStateToString(getMetaState()) + " pointerCount=" + getPointerCount() + " historySize=" + getHistorySize() - + " flags=0x" + Integer.toHexString(mFlags) - + " edgeFlags=0x" + Integer.toHexString(mEdgeFlags) - + " device=" + mDeviceId - + " source=0x" + Integer.toHexString(mSource) + + " flags=0x" + Integer.toHexString(getFlags()) + + " edgeFlags=0x" + Integer.toHexString(getEdgeFlags()) + + " device=" + getDeviceId() + + " source=0x" + Integer.toHexString(getSource()) + (getPointerCount() > 1 ? " pointerId2=" + getPointerId(1) + " x2=" + getX(1) + " y2=" + getY(1) : "") + "}"; @@ -1583,7 +1706,8 @@ public final class MotionEvent extends InputEvent implements Parcelable { /** * Returns a string that represents the symbolic name of the specified action - * such as "ACTION_DOWN", "ACTION_POINTER_DOWN(3)" or "35" (if unknown). + * such as "ACTION_DOWN", "ACTION_POINTER_DOWN(3)" or an equivalent numeric constant + * such as "35" if unknown. * * @param action The action. * @return The symbolic name of the specified action. @@ -1611,6 +1735,39 @@ public final class MotionEvent extends InputEvent implements Parcelable { } } + /** + * Returns a string that represents the symbolic name of the specified axis + * such as "AXIS_X" or an equivalent numeric constants such as "42" if unknown. + * + * @param axis The axis + * @return The symbolic name of the specified axis. + * @hide + */ + public static String axisToString(int axis) { + switch (axis) { + case AXIS_X: + return "AXIS_X"; + case AXIS_Y: + return "AXIS_Y"; + case AXIS_PRESSURE: + return "AXIS_PRESSURE"; + case AXIS_SIZE: + return "AXIS_SIZE"; + case AXIS_TOUCH_MAJOR: + return "AXIS_TOUCH_MAJOR"; + case AXIS_TOUCH_MINOR: + return "AXIS_TOUCH_MINOR"; + case AXIS_TOOL_MAJOR: + return "AXIS_TOOL_MAJOR"; + case AXIS_TOOL_MINOR: + return "AXIS_TOOL_MINOR"; + case AXIS_ORIENTATION: + return "AXIS_ORIENTATION"; + default: + return Integer.toString(axis); + } + } + public static final Parcelable.Creator<MotionEvent> CREATOR = new Parcelable.Creator<MotionEvent>() { public MotionEvent createFromParcel(Parcel in) { @@ -1625,84 +1782,16 @@ public final class MotionEvent extends InputEvent implements Parcelable { /** @hide */ public static MotionEvent createFromParcelBody(Parcel in) { - final int NP = in.readInt(); - final int NS = in.readInt(); - final int NI = NP * NS * NUM_SAMPLE_DATA; - - MotionEvent ev = obtain(NP, NS); - ev.mNumPointers = NP; - ev.mNumSamples = NS; - - ev.readBaseFromParcel(in); - - ev.mDownTimeNano = in.readLong(); - ev.mAction = in.readInt(); - ev.mXOffset = in.readFloat(); - ev.mYOffset = in.readFloat(); - ev.mXPrecision = in.readFloat(); - ev.mYPrecision = in.readFloat(); - ev.mEdgeFlags = in.readInt(); - ev.mMetaState = in.readInt(); - ev.mFlags = in.readInt(); - - final int[] pointerIdentifiers = ev.mPointerIdentifiers; - for (int i = 0; i < NP; i++) { - pointerIdentifiers[i] = in.readInt(); - } - - final long[] eventTimeNanoSamples = ev.mEventTimeNanoSamples; - for (int i = 0; i < NS; i++) { - eventTimeNanoSamples[i] = in.readLong(); - } - - final float[] dataSamples = ev.mDataSamples; - for (int i = 0; i < NI; i++) { - dataSamples[i] = in.readFloat(); - } - - ev.mLastEventTimeNanoSampleIndex = NS - 1; - ev.mLastDataSampleIndex = (NS - 1) * NP * NUM_SAMPLE_DATA; + MotionEvent ev = obtain(); + ev.mNativePtr = nativeReadFromParcel(ev.mNativePtr, in); return ev; } - + public void writeToParcel(Parcel out, int flags) { out.writeInt(PARCEL_TOKEN_MOTION_EVENT); - - final int NP = mNumPointers; - final int NS = mNumSamples; - final int NI = NP * NS * NUM_SAMPLE_DATA; - - out.writeInt(NP); - out.writeInt(NS); - - writeBaseToParcel(out); - - out.writeLong(mDownTimeNano); - out.writeInt(mAction); - out.writeFloat(mXOffset); - out.writeFloat(mYOffset); - out.writeFloat(mXPrecision); - out.writeFloat(mYPrecision); - out.writeInt(mEdgeFlags); - out.writeInt(mMetaState); - out.writeInt(mFlags); - - final int[] pointerIdentifiers = mPointerIdentifiers; - for (int i = 0; i < NP; i++) { - out.writeInt(pointerIdentifiers[i]); - } - - final long[] eventTimeNanoSamples = mEventTimeNanoSamples; - for (int i = 0; i < NS; i++) { - out.writeLong(eventTimeNanoSamples[i]); - } - - final float[] dataSamples = mDataSamples; - for (int i = 0; i < NI; i++) { - out.writeFloat(dataSamples[i]); - } + nativeWriteToParcel(mNativePtr, out); } - + /** * Transfer object for pointer coordinates. * @@ -1713,49 +1802,87 @@ public final class MotionEvent extends InputEvent implements Parcelable { * input devices and sources represent pointer coordinates. */ public static final class PointerCoords { + private static final int INITIAL_PACKED_AXIS_VALUES = 8; + private int mPackedAxisBits; // 32bits are enough for now, can raise to 64bit when needed + private float[] mPackedAxisValues; + + /** + * Creates a pointer coords object with all axes initialized to zero. + */ + public PointerCoords() { + } + + /** + * Creates a pointer coords object as a copy of the + * contents of another pointer coords object. + * + * @param other The pointer coords object to copy. + */ + public PointerCoords(PointerCoords other) { + copyFrom(other); + } + /** * The X coordinate of the pointer movement. - * The interpretation varies by input source and may represent the position of - * the center of the contact area, a relative displacement in device-specific units - * or something else. + * The interpretation of the X axis varies by input source. + * It may represent the X position of the center of the touch contact area, + * a relative horizontal displacement of a trackball or joystick, or something else. + * + * @see MotionEvent#AXIS_X */ public float x; /** * The Y coordinate of the pointer movement. - * The interpretation varies by input source and may represent the position of - * the center of the contact area, a relative displacement in device-specific units - * or something else. + * The interpretation of the Y axis varies by input source. + * It may represent the Y position of the center of the touch contact area, + * a relative vertical displacement of a trackball or joystick, or something else. + * + * @see MotionEvent#AXIS_Y */ public float y; /** - * A scaled value that describes the pressure applied to the pointer. + * A normalized value that describes the pressure applied to the device + * by a finger or other tool. * The pressure generally ranges from 0 (no pressure at all) to 1 (normal pressure), - * however values higher than 1 may be generated depending on the calibration of + * although values higher than 1 may be generated depending on the calibration of * the input device. + * + * @see MotionEvent#AXIS_PRESSURE */ public float pressure; /** - * A scaled value of the approximate size of the pointer touch area. - * This represents some approximation of the area of the screen being + * A normalized value that describes the approximate size of the pointer touch area + * in relation to the maximum detectable size of the device. + * It represents some approximation of the area of the screen being * pressed; the actual value in pixels corresponding to the * touch is normalized with the device specific range of values * and scaled to a value between 0 and 1. The value of size can be used to * determine fat touch events. + * + * @see MotionEvent#AXIS_SIZE */ public float size; /** * The length of the major axis of an ellipse that describes the touch area at * the point of contact. + * If the device is a touch screen, the length is reported in pixels, otherwise it is + * reported in device-specific units. + * + * @see MotionEvent#AXIS_TOUCH_MAJOR */ public float touchMajor; /** * The length of the minor axis of an ellipse that describes the touch area at * the point of contact. + * If the device is a touch screen, the length is reported in pixels, otherwise it is + * reported in device-specific units. + * + * @see MotionEvent#AXIS_TOUCH_MINOR */ public float touchMinor; @@ -1764,6 +1891,10 @@ public final class MotionEvent extends InputEvent implements Parcelable { * the approaching tool. * The tool area represents the estimated size of the finger or pen that is * touching the device independent of its actual touch area at the point of contact. + * If the device is a touch screen, the length is reported in pixels, otherwise it is + * reported in device-specific units. + * + * @see MotionEvent#AXIS_TOOL_MAJOR */ public float toolMajor; @@ -1772,6 +1903,10 @@ public final class MotionEvent extends InputEvent implements Parcelable { * the approaching tool. * The tool area represents the estimated size of the finger or pen that is * touching the device independent of its actual touch area at the point of contact. + * If the device is a touch screen, the length is reported in pixels, otherwise it is + * reported in device-specific units. + * + * @see MotionEvent#AXIS_TOOL_MINOR */ public float toolMinor; @@ -1783,27 +1918,168 @@ public final class MotionEvent extends InputEvent implements Parcelable { * indicates that the major axis of contact is oriented to the left. * The full range is from -PI/2 radians (finger pointing fully left) to PI/2 radians * (finger pointing fully right). + * + * @see MotionEvent#AXIS_ORIENTATION */ public float orientation; - - /* - private static final float PI_4 = (float) (Math.PI / 4); - - public float getTouchWidth() { - return Math.abs(orientation) > PI_4 ? touchMajor : touchMinor; + + /** + * Clears the contents of this object. + * Resets all axes to zero. + */ + public void clear() { + mPackedAxisBits = 0; + + x = 0; + y = 0; + pressure = 0; + size = 0; + touchMajor = 0; + touchMinor = 0; + toolMajor = 0; + toolMinor = 0; + orientation = 0; } - - public float getTouchHeight() { - return Math.abs(orientation) > PI_4 ? touchMinor : touchMajor; + + /** + * Copies the contents of another pointer coords object. + * + * @param other The pointer coords object to copy. + */ + public void copyFrom(PointerCoords other) { + final int bits = other.mPackedAxisBits; + mPackedAxisBits = bits; + if (bits != 0) { + final float[] otherValues = other.mPackedAxisValues; + final int count = Integer.bitCount(bits); + float[] values = mPackedAxisValues; + if (values == null || count > values.length) { + values = new float[otherValues.length]; + mPackedAxisValues = values; + } + System.arraycopy(otherValues, 0, values, 0, count); + } + + x = other.x; + y = other.y; + pressure = other.pressure; + size = other.size; + touchMajor = other.touchMajor; + touchMinor = other.touchMinor; + toolMajor = other.toolMajor; + toolMinor = other.toolMinor; + orientation = other.orientation; } - - public float getToolWidth() { - return Math.abs(orientation) > PI_4 ? toolMajor : toolMinor; + + /** + * Gets the value associated with the specified axis. + * + * @param axis The axis identifier for the axis value to retrieve. + * @return The value associated with the axis, or 0 if none. + * + * @see MotionEvent#AXIS_X + * @see MotionEvent#AXIS_Y + */ + public float getAxisValue(int axis) { + switch (axis) { + case AXIS_X: + return x; + case AXIS_Y: + return y; + case AXIS_PRESSURE: + return pressure; + case AXIS_SIZE: + return size; + case AXIS_TOUCH_MAJOR: + return touchMajor; + case AXIS_TOUCH_MINOR: + return touchMinor; + case AXIS_TOOL_MAJOR: + return toolMajor; + case AXIS_TOOL_MINOR: + return toolMinor; + case AXIS_ORIENTATION: + return orientation; + default: { + final int bits = mPackedAxisBits; + final int axisBit = 1 << axis; + if ((bits & axisBit) == 0) { + return 0; + } + final int index = Integer.bitCount(bits & (axisBit - 1)); + return mPackedAxisValues[index]; + } + } } - - public float getToolHeight() { - return Math.abs(orientation) > PI_4 ? toolMinor : toolMajor; + + /** + * Sets the value associated with the specified axis. + * + * @param axis The axis identifier for the axis value to assign. + * @param value The value to set. + * + * @see MotionEvent#AXIS_X + * @see MotionEvent#AXIS_Y + */ + public void setAxisValue(int axis, float value) { + switch (axis) { + case AXIS_X: + x = value; + break; + case AXIS_Y: + y = value; + break; + case AXIS_PRESSURE: + pressure = value; + break; + case AXIS_SIZE: + size = value; + break; + case AXIS_TOUCH_MAJOR: + touchMajor = value; + break; + case AXIS_TOUCH_MINOR: + touchMinor = value; + break; + case AXIS_TOOL_MAJOR: + toolMajor = value; + break; + case AXIS_TOOL_MINOR: + toolMinor = value; + break; + case AXIS_ORIENTATION: + orientation = value; + break; + default: { + final int bits = mPackedAxisBits; + final int axisBit = 1 << axis; + final int index = Integer.bitCount(bits & (axisBit - 1)); + float[] values = mPackedAxisValues; + if ((bits & axisBit) == 0) { + if (values == null) { + values = new float[INITIAL_PACKED_AXIS_VALUES]; + mPackedAxisValues = values; + } else { + final int count = Integer.bitCount(bits); + if (count < values.length) { + if (index != count) { + System.arraycopy(values, index, values, index + 1, + count - index); + } + } else { + float[] newValues = new float[count * 2]; + System.arraycopy(values, 0, newValues, 0, index); + System.arraycopy(values, index, newValues, index + 1, + count - index); + values = newValues; + mPackedAxisValues = values; + } + } + mPackedAxisBits = bits | axisBit; + } + values[index] = value; + } + } } - */ } } |