frameworks/base/core/java/android/view/MotionEvent.java

   1 /*
   2  * Copyright (C) 2007 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package android.view;
  18
  19 import android.os.Parcel;
  20 import android.os.Parcelable;
  21 import android.os.SystemClock;
  22
  23 /**
  24  * Object used to report movement (mouse, pen, finger, trackball) events.  This
  25  * class may hold either absolute or relative movements, depending on what
  26  * it is being used for.
  27  * <p>
  28  * On pointing devices such as touch screens, pointer coordinates specify absolute
  29  * positions such as view X/Y coordinates.  Each complete gesture is represented
  30  * by a sequence of motion events with actions that describe pointer state transitions
  31  * and movements.  A gesture starts with a motion event with {@link #ACTION_DOWN}
  32  * that provides the location of the first pointer down.  As each additional
  33  * pointer that goes down or up, the framework will generate a motion event with
  34  * {@link #ACTION_POINTER_DOWN} or {@link #ACTION_POINTER_UP} accordingly.
  35  * Pointer movements are described by motion events with {@link #ACTION_MOVE}.
  36  * Finally, a gesture end either when the final pointer goes up as represented
  37  * by a motion event with {@link #ACTION_UP} or when gesture is canceled
  38  * with {@link #ACTION_CANCEL}.
  39  * </p><p>
  40  * On trackballs, the pointer coordinates specify relative movements as X/Y deltas.
  41  * A trackball gesture consists of a sequence of movements described by motion
  42  * events with {@link #ACTION_MOVE} interspersed with occasional {@link #ACTION_DOWN}
  43  * or {@link #ACTION_UP} motion events when the trackball button is pressed or released.
  44  * </p><p>
  45  * Motion events always report movements for all pointers at once.  The number
  46  * of pointers only ever changes by one as individual pointers go up and down,
  47  * except when the gesture is canceled.
  48  * </p><p>
  49  * The order in which individual pointers appear within a motion event can change
  50  * from one event to the next. Use the {@link #getPointerId(int)} method to obtain a
  51  * pointer id to track pointers across motion events in a gesture.  Then for
  52  * successive motion events, use the {@link #findPointerIndex(int)} method to obtain
  53  * the pointer index for a given pointer id in that motion event.
  54  * </p><p>
  55  * For efficiency, motion events with {@link #ACTION_MOVE} may batch together
  56  * multiple movement samples within a single object.  The most current
  57  * pointer coordinates are available using {@link #getX(int)} and {@link #getY(int)}.
  58  * Earlier coordinates within the batch are accessed using {@link #getHistoricalX(int, int)}
  59  * and {@link #getHistoricalY(int, int)}.  The coordinates are "historical" only
  60  * insofar as they are older than the current coordinates in the batch; however,
  61  * they are still distinct from any other coordinates reported in prior motion events.
  62  * To process all coordinates in the batch in time order, first consume the historical
  63  * coordinates then consume the current coordinates.
  64  * </p><p>
  65  * Example: Consuming all samples for all pointers in a motion event in time order.
  66  * </p><p><pre><code>
  67  * void printSamples(MotionEvent ev) {
  68  *     final int historySize = ev.getHistorySize();
  69  *     final int pointerCount = ev.getPointerCount();
  70  *     for (int h = 0; h &lt; historySize; h++) {
  71  *         System.out.printf("At time %d:", ev.getHistoricalEventTime(h));
  72  *         for (int p = 0; p &lt; pointerCount; p++) {
  73  *             System.out.printf("  pointer %d: (%f,%f)",
  74  *                 ev.getPointerId(p), ev.getHistoricalX(p, h), ev.getHistoricalY(p, h));
  75  *         }
  76  *     }
  77  *     System.out.printf("At time %d:", ev.getEventTime());
  78  *     for (int p = 0; p &lt; pointerCount; p++) {
  79  *         System.out.printf("  pointer %d: (%f,%f)",
  80  *             ev.getPointerId(p), ev.getX(p), ev.getY(p));
  81  *     }
  82  * }
  83  * </code></pre></p><p>
  84  * In general, the framework cannot guarantee that the motion events it delivers
  85  * to a view always constitute a complete motion sequences since some events may be dropped
  86  * or modified by containing views before they are delivered.  The view implementation
  87  * should be prepared to handle {@link #ACTION_CANCEL} and should tolerate anomalous
  88  * situations such as receiving a new {@link #ACTION_DOWN} without first having
  89  * received an {@link #ACTION_UP} for the prior gesture.
  90  * </p><p>
  91  * Refer to {@link InputDevice} for more information about how different kinds of
  92  * input devices and sources represent pointer coordinates.
  93  * </p>
  94  */
  95 public final class MotionEvent extends InputEvent implements Parcelable {
  96     private static final long MS_PER_NS = 1000000;
  97     private static final boolean TRACK_RECYCLED_LOCATION = false;
  98
  99     /**
 100      * Bit mask of the parts of the action code that are the action itself.
 101      */
 102     public static final int ACTION_MASK             = 0xff;
 103
 104     /**
 105      * Constant for {@link #getAction}: A pressed gesture has started, the
 106      * motion contains the initial starting location.
 107      */
 108     public static final int ACTION_DOWN             = 0;
 109
 110     /**
 111      * Constant for {@link #getAction}: A pressed gesture has finished, the
 112      * motion contains the final release location as well as any intermediate
 113      * points since the last down or move event.
 114      */
 115     public static final int ACTION_UP               = 1;
 116
 117     /**
 118      * Constant for {@link #getAction}: A change has happened during a
 119      * press gesture (between {@link #ACTION_DOWN} and {@link #ACTION_UP}).
 120      * The motion contains the most recent point, as well as any intermediate
 121      * points since the last down or move event.
 122      */
 123     public static final int ACTION_MOVE             = 2;
 124
 125     /**
 126      * Constant for {@link #getAction}: The current gesture has been aborted.
 127      * You will not receive any more points in it.  You should treat this as
 128      * an up event, but not perform any action that you normally would.
 129      */
 130     public static final int ACTION_CANCEL           = 3;
 131
 132     /**
 133      * Constant for {@link #getAction}: A movement has happened outside of the
 134      * normal bounds of the UI element.  This does not provide a full gesture,
 135      * but only the initial location of the movement/touch.
 136      */
 137     public static final int ACTION_OUTSIDE          = 4;
 138
 139     /**
 140      * A non-primary pointer has gone down.  The bits in
 141      * {@link #ACTION_POINTER_ID_MASK} indicate which pointer changed.
 142      */
 143     public static final int ACTION_POINTER_DOWN     = 5;
 144
 145     /**
 146      * A non-primary pointer has gone up.  The bits in
 147      * {@link #ACTION_POINTER_ID_MASK} indicate which pointer changed.
 148      */
 149     public static final int ACTION_POINTER_UP       = 6;
 150
 151     /**
 152      * Bits in the action code that represent a pointer index, used with
 153      * {@link #ACTION_POINTER_DOWN} and {@link #ACTION_POINTER_UP}.  Shifting
 154      * down by {@link #ACTION_POINTER_INDEX_SHIFT} provides the actual pointer
 155      * index where the data for the pointer going up or down can be found; you can
 156      * get its identifier with {@link #getPointerId(int)} and the actual
 157      * data with {@link #getX(int)} etc.
 158      */
 159     public static final int ACTION_POINTER_INDEX_MASK  = 0xff00;
 160
 161     /**
 162      * Bit shift for the action bits holding the pointer index as
 163      * defined by {@link #ACTION_POINTER_INDEX_MASK}.
 164      */
 165     public static final int ACTION_POINTER_INDEX_SHIFT = 8;
 166
 167     /**
 168      * @deprecated Use {@link #ACTION_POINTER_INDEX_MASK} to retrieve the
 169      * data index associated with {@link #ACTION_POINTER_DOWN}.
 170      */
 171     @Deprecated
 172     public static final int ACTION_POINTER_1_DOWN   = ACTION_POINTER_DOWN | 0x0000;
 173
 174     /**
 175      * @deprecated Use {@link #ACTION_POINTER_INDEX_MASK} to retrieve the
 176      * data index associated with {@link #ACTION_POINTER_DOWN}.
 177      */
 178     @Deprecated
 179     public static final int ACTION_POINTER_2_DOWN   = ACTION_POINTER_DOWN | 0x0100;
 180
 181     /**
 182      * @deprecated Use {@link #ACTION_POINTER_INDEX_MASK} to retrieve the
 183      * data index associated with {@link #ACTION_POINTER_DOWN}.
 184      */
 185     @Deprecated
 186     public static final int ACTION_POINTER_3_DOWN   = ACTION_POINTER_DOWN | 0x0200;
 187
 188     /**
 189      * @deprecated Use {@link #ACTION_POINTER_INDEX_MASK} to retrieve the
 190      * data index associated with {@link #ACTION_POINTER_UP}.
 191      */
 192     @Deprecated
 193     public static final int ACTION_POINTER_1_UP     = ACTION_POINTER_UP | 0x0000;
 194
 195     /**
 196      * @deprecated Use {@link #ACTION_POINTER_INDEX_MASK} to retrieve the
 197      * data index associated with {@link #ACTION_POINTER_UP}.
 198      */
 199     @Deprecated
 200     public static final int ACTION_POINTER_2_UP     = ACTION_POINTER_UP | 0x0100;
 201
 202     /**
 203      * @deprecated Use {@link #ACTION_POINTER_INDEX_MASK} to retrieve the
 204      * data index associated with {@link #ACTION_POINTER_UP}.
 205      */
 206     @Deprecated
 207     public static final int ACTION_POINTER_3_UP     = ACTION_POINTER_UP | 0x0200;
 208
 209     /**
 210      * @deprecated Renamed to {@link #ACTION_POINTER_INDEX_MASK} to match
 211      * the actual data contained in these bits.
 212      */
 213     @Deprecated
 214     public static final int ACTION_POINTER_ID_MASK  = 0xff00;
 215
 216     /**
 217      * @deprecated Renamed to {@link #ACTION_POINTER_INDEX_SHIFT} to match
 218      * the actual data contained in these bits.
 219      */
 220     @Deprecated
 221     public static final int ACTION_POINTER_ID_SHIFT = 8;
 222
 223     /**
 224      * This flag indicates that the window that received this motion event is partly
 225      * or wholly obscured by another visible window above it.  This flag is set to true
 226      * even if the event did not directly pass through the obscured area.
 227      * A security sensitive application can check this flag to identify situations in which
 228      * a malicious application may have covered up part of its content for the purpose
 229      * of misleading the user or hijacking touches.  An appropriate response might be
 230      * to drop the suspect touches or to take additional precautions to confirm the user's
 231      * actual intent.
 232      */
 233     public static final int FLAG_WINDOW_IS_OBSCURED = 0x1;
 234
 235     /**
 236      * Flag indicating the motion event intersected the top edge of the screen.
 237      */
 238     public static final int EDGE_TOP = 0x00000001;
 239
 240     /**
 241      * Flag indicating the motion event intersected the bottom edge of the screen.
 242      */
 243     public static final int EDGE_BOTTOM = 0x00000002;
 244
 245     /**
 246      * Flag indicating the motion event intersected the left edge of the screen.
 247      */
 248     public static final int EDGE_LEFT = 0x00000004;
 249
 250     /**
 251      * Flag indicating the motion event intersected the right edge of the screen.
 252      */
 253     public static final int EDGE_RIGHT = 0x00000008;
 254
 255     /*
 256      * Offset for the sample's X coordinate.
 257      */
 258     static private final int SAMPLE_X = 0;
 259
 260     /*
 261      * Offset for the sample's Y coordinate.
 262      */
 263     static private final int SAMPLE_Y = 1;
 264
 265     /*
 266      * Offset for the sample's pressure.
 267      */
 268     static private final int SAMPLE_PRESSURE = 2;
 269
 270     /*
 271      * Offset for the sample's size
 272      */
 273     static private final int SAMPLE_SIZE = 3;
 274
 275     /*
 276      * Offset for the sample's touch major axis length.
 277      */
 278     static private final int SAMPLE_TOUCH_MAJOR = 4;
 279
 280     /*
 281      * Offset for the sample's touch minor axis length.
 282      */
 283     static private final int SAMPLE_TOUCH_MINOR = 5;
 284
 285     /*
 286      * Offset for the sample's tool major axis length.
 287      */
 288     static private final int SAMPLE_TOOL_MAJOR = 6;
 289
 290     /*
 291      * Offset for the sample's tool minor axis length.
 292      */
 293     static private final int SAMPLE_TOOL_MINOR = 7;
 294
 295     /*
 296      * Offset for the sample's orientation.
 297      */
 298     static private final int SAMPLE_ORIENTATION = 8;
 299
 300     /*
 301      * Number of data items for each sample.
 302      */
 303     static private final int NUM_SAMPLE_DATA = 9;
 304
 305     /*
 306      * Minimum number of pointers for which to reserve space when allocating new
 307      * motion events.  This is explicitly not a bound on the maximum number of pointers.
 308      */
 309     static private final int BASE_AVAIL_POINTERS = 5;
 310
 311     /*
 312      * Minimum number of samples for which to reserve space when allocating new motion events.
 313      */
 314     static private final int BASE_AVAIL_SAMPLES = 8;
 315
 316     static private final int MAX_RECYCLED = 10;
 317     static private Object gRecyclerLock = new Object();
 318     static private int gRecyclerUsed = 0;
 319     static private MotionEvent gRecyclerTop = null;
 320
 321     private long mDownTimeNano;
 322     private int mAction;
 323     private float mXOffset;
 324     private float mYOffset;
 325     private float mXPrecision;
 326     private float mYPrecision;
 327     private int mEdgeFlags;
 328     private int mMetaState;
 329     private int mFlags;
 330
 331     private int mNumPointers;
 332     private int mNumSamples;
 333
 334     private int mLastDataSampleIndex;
 335     private int mLastEventTimeNanoSampleIndex;
 336
 337     // Array of mNumPointers size of identifiers for each pointer of data.
 338     private int[] mPointerIdentifiers;
 339
 340     // Array of (mNumSamples * mNumPointers * NUM_SAMPLE_DATA) size of event data.
 341     // Samples are ordered from oldest to newest.
 342     private float[] mDataSamples;
 343
 344     // Array of mNumSamples size of event time stamps in nanoseconds.
 345     // Samples are ordered from oldest to newest.
 346     private long[] mEventTimeNanoSamples;
 347
 348     private MotionEvent mNext;
 349     private RuntimeException mRecycledLocation;
 350     private boolean mRecycled;
 351
 352     private MotionEvent(int pointerCount, int sampleCount) {
 353         mPointerIdentifiers = new int[pointerCount];
 354         mDataSamples = new float[pointerCount * sampleCount * NUM_SAMPLE_DATA];
 355         mEventTimeNanoSamples = new long[sampleCount];
 356     }
 357
 358     static private MotionEvent obtain(int pointerCount, int sampleCount) {
 359         final MotionEvent ev;
 360         synchronized (gRecyclerLock) {
 361             if (gRecyclerTop == null) {
 362                 if (pointerCount < BASE_AVAIL_POINTERS) {
 363                     pointerCount = BASE_AVAIL_POINTERS;
 364                 }
 365                 if (sampleCount < BASE_AVAIL_SAMPLES) {
 366                     sampleCount = BASE_AVAIL_SAMPLES;
 367                 }
 368                 return new MotionEvent(pointerCount, sampleCount);
 369             }
 370             ev = gRecyclerTop;
 371             gRecyclerTop = ev.mNext;
 372             gRecyclerUsed -= 1;
 373         }
 374         ev.mRecycledLocation = null;
 375         ev.mRecycled = false;
 376         ev.mNext = null;
 377
 378         if (ev.mPointerIdentifiers.length < pointerCount) {
 379             ev.mPointerIdentifiers = new int[pointerCount];
 380         }
 381
 382         if (ev.mEventTimeNanoSamples.length < sampleCount) {
 383             ev.mEventTimeNanoSamples = new long[sampleCount];
 384         }
 385
 386         final int neededDataSamplesLength = pointerCount * sampleCount * NUM_SAMPLE_DATA;
 387         if (ev.mDataSamples.length < neededDataSamplesLength) {
 388             ev.mDataSamples = new float[neededDataSamplesLength];
 389         }
 390
 391         return ev;
 392     }
 393
 394     /**
 395      * Create a new MotionEvent, filling in all of the basic values that
 396      * define the motion.
 397      *
 398      * @param downTime The time (in ms) when the user originally pressed down to start
 399      * a stream of position events.  This must be obtained from {@link SystemClock#uptimeMillis()}.
 400      * @param eventTime The the time (in ms) when this specific event was generated.  This
 401      * must be obtained from {@link SystemClock#uptimeMillis()}.
 402      * @param action The kind of action being performed -- one of either
 403      * {@link #ACTION_DOWN}, {@link #ACTION_MOVE}, {@link #ACTION_UP}, or
 404      * {@link #ACTION_CANCEL}.
 405      * @param pointers The number of points that will be in this event.
 406      * @param pointerIds An array of <em>pointers</em> values providing
 407      * an identifier for each pointer.
 408      * @param pointerCoords An array of <em>pointers</em> values providing
 409      * a {@link PointerCoords} coordinate object for each pointer.
 410      * @param metaState The state of any meta / modifier keys that were in effect when
 411      * the event was generated.
 412      * @param xPrecision The precision of the X coordinate being reported.
 413      * @param yPrecision The precision of the Y coordinate being reported.
 414      * @param deviceId The id for the device that this event came from.  An id of
 415      * zero indicates that the event didn't come from a physical device; other
 416      * numbers are arbitrary and you shouldn't depend on the values.
 417      * @param edgeFlags A bitfield indicating which edges, if any, were touched by this
 418      * MotionEvent.
 419      * @param source The source of this event.
 420      * @param flags The motion event flags.
 421      */
 422     static public MotionEvent obtain(long downTime, long eventTime,
 423             int action, int pointers, int[] pointerIds, PointerCoords[] pointerCoords,
 424             int metaState, float xPrecision, float yPrecision, int deviceId,
 425             int edgeFlags, int source, int flags) {
 426         MotionEvent ev = obtain(pointers, 1);
 427         ev.mDeviceId = deviceId;
 428         ev.mSource = source;
 429         ev.mEdgeFlags = edgeFlags;
 430         ev.mDownTimeNano = downTime * MS_PER_NS;
 431         ev.mAction = action;
 432         ev.mFlags = flags;
 433         ev.mMetaState = metaState;
 434         ev.mXOffset = 0;
 435         ev.mYOffset = 0;
 436         ev.mXPrecision = xPrecision;
 437         ev.mYPrecision = yPrecision;
 438
 439         ev.mNumPointers = pointers;
 440         ev.mNumSamples = 1;
 441
 442         ev.mLastDataSampleIndex = 0;
 443         ev.mLastEventTimeNanoSampleIndex = 0;
 444
 445         System.arraycopy(pointerIds, 0, ev.mPointerIdentifiers, 0, pointers);
 446
 447         ev.mEventTimeNanoSamples[0] = eventTime * MS_PER_NS;
 448
 449         ev.setPointerCoordsAtSampleIndex(0, pointerCoords);
 450
 451         return ev;
 452     }
 453
 454     /**
 455      * Create a new MotionEvent, filling in all of the basic values that
 456      * define the motion.
 457      *
 458      * @param downTime The time (in ms) when the user originally pressed down to start
 459      * a stream of position events.  This must be obtained from {@link SystemClock#uptimeMillis()}.
 460      * @param eventTime  The the time (in ms) when this specific event was generated.  This
 461      * must be obtained from {@link SystemClock#uptimeMillis()}.
 462      * @param action The kind of action being performed -- one of either
 463      * {@link #ACTION_DOWN}, {@link #ACTION_MOVE}, {@link #ACTION_UP}, or
 464      * {@link #ACTION_CANCEL}.
 465      * @param x The X coordinate of this event.
 466      * @param y The Y coordinate of this event.
 467      * @param pressure The current pressure of this event.  The pressure generally
 468      * ranges from 0 (no pressure at all) to 1 (normal pressure), however
 469      * values higher than 1 may be generated depending on the calibration of
 470      * the input device.
 471      * @param size A scaled value of the approximate size of the area being pressed when
 472      * touched with the finger. The actual value in pixels corresponding to the finger
 473      * touch is normalized with a device specific range of values
 474      * and scaled to a value between 0 and 1.
 475      * @param metaState The state of any meta / modifier keys that were in effect when
 476      * the event was generated.
 477      * @param xPrecision The precision of the X coordinate being reported.
 478      * @param yPrecision The precision of the Y coordinate being reported.
 479      * @param deviceId The id for the device that this event came from.  An id of
 480      * zero indicates that the event didn't come from a physical device; other
 481      * numbers are arbitrary and you shouldn't depend on the values.
 482      * @param edgeFlags A bitfield indicating which edges, if any, were touched by this
 483      * MotionEvent.
 484      */
 485     static public MotionEvent obtain(long downTime, long eventTime, int action,
 486             float x, float y, float pressure, float size, int metaState,
 487             float xPrecision, float yPrecision, int deviceId, int edgeFlags) {
 488         MotionEvent ev = obtain(1, 1);
 489         ev.mDeviceId = deviceId;
 490         ev.mSource = InputDevice.SOURCE_UNKNOWN;
 491         ev.mEdgeFlags = edgeFlags;
 492         ev.mDownTimeNano = downTime * MS_PER_NS;
 493         ev.mAction = action;
 494         ev.mFlags = 0;
 495         ev.mMetaState = metaState;
 496         ev.mXOffset = 0;
 497         ev.mYOffset = 0;
 498         ev.mXPrecision = xPrecision;
 499         ev.mYPrecision = yPrecision;
 500
 501         ev.mNumPointers = 1;
 502         ev.mNumSamples = 1;
 503
 504         ev.mLastDataSampleIndex = 0;
 505         ev.mLastEventTimeNanoSampleIndex = 0;
 506
 507         ev.mPointerIdentifiers[0] = 0;
 508
 509         ev.mEventTimeNanoSamples[0] = eventTime * MS_PER_NS;
 510
 511         ev.setPointerCoordsAtSampleIndex(0, x, y, pressure, size);
 512         return ev;
 513     }
 514
 515     /**
 516      * Create a new MotionEvent, filling in all of the basic values that
 517      * define the motion.
 518      *
 519      * @param downTime The time (in ms) when the user originally pressed down to start
 520      * a stream of position events.  This must be obtained from {@link SystemClock#uptimeMillis()}.
 521      * @param eventTime  The the time (in ms) when this specific event was generated.  This
 522      * must be obtained from {@link SystemClock#uptimeMillis()}.
 523      * @param action The kind of action being performed -- one of either
 524      * {@link #ACTION_DOWN}, {@link #ACTION_MOVE}, {@link #ACTION_UP}, or
 525      * {@link #ACTION_CANCEL}.
 526      * @param pointers The number of pointers that are active in this event.
 527      * @param x The X coordinate of this event.
 528      * @param y The Y coordinate of this event.
 529      * @param pressure The current pressure of this event.  The pressure generally
 530      * ranges from 0 (no pressure at all) to 1 (normal pressure), however
 531      * values higher than 1 may be generated depending on the calibration of
 532      * the input device.
 533      * @param size A scaled value of the approximate size of the area being pressed when
 534      * touched with the finger. The actual value in pixels corresponding to the finger
 535      * touch is normalized with a device specific range of values
 536      * and scaled to a value between 0 and 1.
 537      * @param metaState The state of any meta / modifier keys that were in effect when
 538      * the event was generated.
 539      * @param xPrecision The precision of the X coordinate being reported.
 540      * @param yPrecision The precision of the Y coordinate being reported.
 541      * @param deviceId The id for the device that this event came from.  An id of
 542      * zero indicates that the event didn't come from a physical device; other
 543      * numbers are arbitrary and you shouldn't depend on the values.
 544      * @param edgeFlags A bitfield indicating which edges, if any, were touched by this
 545      * MotionEvent.
 546      *
 547      * @deprecated Use {@link #obtain(long, long, int, float, float, float, float, int, float, float, int, int)}
 548      * instead.
 549      */
 550     @Deprecated
 551     static public MotionEvent obtain(long downTime, long eventTime, int action,
 552             int pointers, float x, float y, float pressure, float size, int metaState,
 553             float xPrecision, float yPrecision, int deviceId, int edgeFlags) {
 554         return obtain(downTime, eventTime, action, x, y, pressure, size,
 555                 metaState, xPrecision, yPrecision, deviceId, edgeFlags);
 556     }
 557
 558     /**
 559      * Create a new MotionEvent, filling in a subset of the basic motion
 560      * values.  Those not specified here are: device id (always 0), pressure
 561      * and size (always 1), x and y precision (always 1), and edgeFlags (always 0).
 562      *
 563      * @param downTime The time (in ms) when the user originally pressed down to start
 564      * a stream of position events.  This must be obtained from {@link SystemClock#uptimeMillis()}.
 565      * @param eventTime  The the time (in ms) when this specific event was generated.  This
 566      * must be obtained from {@link SystemClock#uptimeMillis()}.
 567      * @param action The kind of action being performed -- one of either
 568      * {@link #ACTION_DOWN}, {@link #ACTION_MOVE}, {@link #ACTION_UP}, or
 569      * {@link #ACTION_CANCEL}.
 570      * @param x The X coordinate of this event.
 571      * @param y The Y coordinate of this event.
 572      * @param metaState The state of any meta / modifier keys that were in effect when
 573      * the event was generated.
 574      */
 575     static public MotionEvent obtain(long downTime, long eventTime, int action,
 576             float x, float y, int metaState) {
 577         return obtain(downTime, eventTime, action, x, y, 1.0f, 1.0f,
 578                 metaState, 1.0f, 1.0f, 0, 0);
 579     }
 580
 581     /**
 582      * Create a new MotionEvent, copying from an existing one.
 583      */
 584     static public MotionEvent obtain(MotionEvent o) {
 585         MotionEvent ev = obtain(o.mNumPointers, o.mNumSamples);
 586         ev.mDeviceId = o.mDeviceId;
 587         ev.mSource = o.mSource;
 588         ev.mEdgeFlags = o.mEdgeFlags;
 589         ev.mDownTimeNano = o.mDownTimeNano;
 590         ev.mAction = o.mAction;
 591         ev.mFlags = o.mFlags;
 592         ev.mMetaState = o.mMetaState;
 593         ev.mXOffset = o.mXOffset;
 594         ev.mYOffset = o.mYOffset;
 595         ev.mXPrecision = o.mXPrecision;
 596         ev.mYPrecision = o.mYPrecision;
 597         int numPointers = ev.mNumPointers = o.mNumPointers;
 598         int numSamples = ev.mNumSamples = o.mNumSamples;
 599
 600         ev.mLastDataSampleIndex = o.mLastDataSampleIndex;
 601         ev.mLastEventTimeNanoSampleIndex = o.mLastEventTimeNanoSampleIndex;
 602
 603         System.arraycopy(o.mPointerIdentifiers, 0, ev.mPointerIdentifiers, 0, numPointers);
 604
 605         System.arraycopy(o.mEventTimeNanoSamples, 0, ev.mEventTimeNanoSamples, 0, numSamples);
 606
 607         System.arraycopy(o.mDataSamples, 0, ev.mDataSamples, 0,
 608                 numPointers * numSamples * NUM_SAMPLE_DATA);
 609         return ev;
 610     }
 611
 612     /**
 613      * Create a new MotionEvent, copying from an existing one, but not including
 614      * any historical point information.
 615      */
 616     static public MotionEvent obtainNoHistory(MotionEvent o) {
 617         MotionEvent ev = obtain(o.mNumPointers, 1);
 618         ev.mDeviceId = o.mDeviceId;
 619         ev.mSource = o.mSource;
 620         ev.mEdgeFlags = o.mEdgeFlags;
 621         ev.mDownTimeNano = o.mDownTimeNano;
 622         ev.mAction = o.mAction;
 623         o.mFlags = o.mFlags;
 624         ev.mMetaState = o.mMetaState;
 625         ev.mXOffset = o.mXOffset;
 626         ev.mYOffset = o.mYOffset;
 627         ev.mXPrecision = o.mXPrecision;
 628         ev.mYPrecision = o.mYPrecision;
 629
 630         int numPointers = ev.mNumPointers = o.mNumPointers;
 631         ev.mNumSamples = 1;
 632
 633         ev.mLastDataSampleIndex = 0;
 634         ev.mLastEventTimeNanoSampleIndex = 0;
 635
 636         System.arraycopy(o.mPointerIdentifiers, 0, ev.mPointerIdentifiers, 0, numPointers);
 637
 638         ev.mEventTimeNanoSamples[0] = o.mEventTimeNanoSamples[o.mLastEventTimeNanoSampleIndex];
 639
 640         System.arraycopy(o.mDataSamples, o.mLastDataSampleIndex, ev.mDataSamples, 0,
 641                 numPointers * NUM_SAMPLE_DATA);
 642         return ev;
 643     }
 644
 645     /**
 646      * Recycle the MotionEvent, to be re-used by a later caller.  After calling
 647      * this function you must not ever touch the event again.
 648      */
 649     public final void recycle() {
 650         // Ensure recycle is only called once!
 651         if (TRACK_RECYCLED_LOCATION) {
 652             if (mRecycledLocation != null) {
 653                 throw new RuntimeException(toString() + " recycled twice!", mRecycledLocation);
 654             }
 655             mRecycledLocation = new RuntimeException("Last recycled here");
 656             //Log.w("MotionEvent", "Recycling event " + this, mRecycledLocation);
 657         } else {
 658             if (mRecycled) {
 659                 throw new RuntimeException(toString() + " recycled twice!");
 660             }
 661             mRecycled = true;
 662         }
 663
 664         synchronized (gRecyclerLock) {
 665             if (gRecyclerUsed < MAX_RECYCLED) {
 666                 gRecyclerUsed++;
 667                 mNumSamples = 0;
 668                 mNext = gRecyclerTop;
 669                 gRecyclerTop = this;
 670             }
 671         }
 672     }
 673
 674     /**
 675      * Scales down the coordination of this event by the given scale.
 676      *
 677      * @hide
 678      */
 679     public final void scale(float scale) {
 680         mXOffset *= scale;
 681         mYOffset *= scale;
 682         mXPrecision *= scale;
 683         mYPrecision *= scale;
 684
 685         float[] history = mDataSamples;
 686         final int length = mNumPointers * mNumSamples * NUM_SAMPLE_DATA;
 687         for (int i = 0; i < length; i += NUM_SAMPLE_DATA) {
 688             history[i + SAMPLE_X] *= scale;
 689             history[i + SAMPLE_Y] *= scale;
 690             // no need to scale pressure
 691             history[i + SAMPLE_SIZE] *= scale;    // TODO: square this?
 692             history[i + SAMPLE_TOUCH_MAJOR] *= scale;
 693             history[i + SAMPLE_TOUCH_MINOR] *= scale;
 694             history[i + SAMPLE_TOOL_MAJOR] *= scale;
 695             history[i + SAMPLE_TOOL_MINOR] *= scale;
 696         }
 697     }
 698
 699     /**
 700      * Return the kind of action being performed -- one of either
 701      * {@link #ACTION_DOWN}, {@link #ACTION_MOVE}, {@link #ACTION_UP}, or
 702      * {@link #ACTION_CANCEL}.  Consider using {@link #getActionMasked}
 703      * and {@link #getActionIndex} to retrieve the separate masked action
 704      * and pointer index.
 705      */
 706     public final int getAction() {
 707         return mAction;
 708     }
 709
 710     /**
 711      * Return the masked action being performed, without pointer index
 712      * information.  May be any of the actions: {@link #ACTION_DOWN},
 713      * {@link #ACTION_MOVE}, {@link #ACTION_UP}, {@link #ACTION_CANCEL},
 714      * {@link #ACTION_POINTER_DOWN}, or {@link #ACTION_POINTER_UP}.
 715      * Use {@link #getActionIndex} to return the index associated with
 716      * pointer actions.
 717      */
 718     public final int getActionMasked() {
 719         return mAction & ACTION_MASK;
 720     }
 721
 722     /**
 723      * For {@link #ACTION_POINTER_DOWN} or {@link #ACTION_POINTER_UP}
 724      * as returned by {@link #getActionMasked}, this returns the associated
 725      * pointer index.  The index may be used with {@link #getPointerId(int)},
 726      * {@link #getX(int)}, {@link #getY(int)}, {@link #getPressure(int)},
 727      * and {@link #getSize(int)} to get information about the pointer that has
 728      * gone down or up.
 729      */
 730     public final int getActionIndex() {
 731         return (mAction & ACTION_POINTER_INDEX_MASK) >> ACTION_POINTER_INDEX_SHIFT;
 732     }
 733
 734     /**
 735      * Gets the motion event flags.
 736      *
 737      * @see #FLAG_WINDOW_IS_OBSCURED
 738      */
 739     public final int getFlags() {
 740         return mFlags;
 741     }
 742
 743     /**
 744      * Returns the time (in ms) when the user originally pressed down to start
 745      * a stream of position events.
 746      */
 747     public final long getDownTime() {
 748         return mDownTimeNano / MS_PER_NS;
 749     }
 750
 751     /**
 752      * Returns the time (in ms) when this specific event was generated.
 753      */
 754     public final long getEventTime() {
 755         return mEventTimeNanoSamples[mLastEventTimeNanoSampleIndex] / MS_PER_NS;
 756     }
 757
 758     /**
 759      * Returns the time (in ns) when this specific event was generated.
 760      * The value is in nanosecond precision but it may not have nanosecond accuracy.
 761      *
 762      * @hide
 763      */
 764     public final long getEventTimeNano() {
 765         return mEventTimeNanoSamples[mLastEventTimeNanoSampleIndex];
 766     }
 767
 768     /**
 769      * {@link #getX(int)} for the first pointer index (may be an
 770      * arbitrary pointer identifier).
 771      */
 772     public final float getX() {
 773         return mDataSamples[mLastDataSampleIndex + SAMPLE_X] + mXOffset;
 774     }
 775
 776     /**
 777      * {@link #getY(int)} for the first pointer index (may be an
 778      * arbitrary pointer identifier).
 779      */
 780     public final float getY() {
 781         return mDataSamples[mLastDataSampleIndex + SAMPLE_Y] + mYOffset;
 782     }
 783
 784     /**
 785      * {@link #getPressure(int)} for the first pointer index (may be an
 786      * arbitrary pointer identifier).
 787      */
 788     public final float getPressure() {
 789         return mDataSamples[mLastDataSampleIndex + SAMPLE_PRESSURE];
 790     }
 791
 792     /**
 793      * {@link #getSize(int)} for the first pointer index (may be an
 794      * arbitrary pointer identifier).
 795      */
 796     public final float getSize() {
 797         return mDataSamples[mLastDataSampleIndex + SAMPLE_SIZE];
 798     }
 799
 800     /**
 801      * {@link #getTouchMajor(int)} for the first pointer index (may be an
 802      * arbitrary pointer identifier).
 803      */
 804     public final float getTouchMajor() {
 805         return mDataSamples[mLastDataSampleIndex + SAMPLE_TOUCH_MAJOR];
 806     }
 807
 808     /**
 809      * {@link #getTouchMinor(int)} for the first pointer index (may be an
 810      * arbitrary pointer identifier).
 811      */
 812     public final float getTouchMinor() {
 813         return mDataSamples[mLastDataSampleIndex + SAMPLE_TOUCH_MINOR];
 814     }
 815
 816     /**
 817      * {@link #getToolMajor(int)} for the first pointer index (may be an
 818      * arbitrary pointer identifier).
 819      */
 820     public final float getToolMajor() {
 821         return mDataSamples[mLastDataSampleIndex + SAMPLE_TOOL_MAJOR];
 822     }
 823
 824     /**
 825      * {@link #getToolMinor(int)} for the first pointer index (may be an
 826      * arbitrary pointer identifier).
 827      */
 828     public final float getToolMinor() {
 829         return mDataSamples[mLastDataSampleIndex + SAMPLE_TOOL_MINOR];
 830     }
 831
 832     /**
 833      * {@link #getOrientation(int)} for the first pointer index (may be an
 834      * arbitrary pointer identifier).
 835      */
 836     public final float getOrientation() {
 837         return mDataSamples[mLastDataSampleIndex + SAMPLE_ORIENTATION];
 838     }
 839
 840     /**
 841      * The number of pointers of data contained in this event.  Always
 842      * >= 1.
 843      */
 844     public final int getPointerCount() {
 845         return mNumPointers;
 846     }
 847
 848     /**
 849      * Return the pointer identifier associated with a particular pointer
 850      * data index is this event.  The identifier tells you the actual pointer
 851      * number associated with the data, accounting for individual pointers
 852      * going up and down since the start of the current gesture.
 853      * @param pointerIndex Raw index of pointer to retrieve.  Value may be from 0
 854      * (the first pointer that is down) to {@link #getPointerCount()}-1.
 855      */
 856     public final int getPointerId(int pointerIndex) {
 857         return mPointerIdentifiers[pointerIndex];
 858     }
 859
 860     /**
 861      * Given a pointer identifier, find the index of its data in the event.
 862      *
 863      * @param pointerId The identifier of the pointer to be found.
 864      * @return Returns either the index of the pointer (for use with
 865      * {@link #getX(int)} et al.), or -1 if there is no data available for
 866      * that pointer identifier.
 867      */
 868     public final int findPointerIndex(int pointerId) {
 869         int i = mNumPointers;
 870         while (i > 0) {
 871             i--;
 872             if (mPointerIdentifiers[i] == pointerId) {
 873                 return i;
 874             }
 875         }
 876         return -1;
 877     }
 878
 879     /**
 880      * Returns the X coordinate of this event for the given pointer
 881      * <em>index</em> (use {@link #getPointerId(int)} to find the pointer
 882      * identifier for this index).
 883      * Whole numbers are pixels; the
 884      * value may have a fraction for input devices that are sub-pixel precise.
 885      * @param pointerIndex Raw index of pointer to retrieve.  Value may be from 0
 886      * (the first pointer that is down) to {@link #getPointerCount()}-1.
 887      */
 888     public final float getX(int pointerIndex) {
 889         return mDataSamples[mLastDataSampleIndex
 890                             + pointerIndex * NUM_SAMPLE_DATA + SAMPLE_X] + mXOffset;
 891     }
 892
 893     /**
 894      * Returns the Y coordinate of this event for the given pointer
 895      * <em>index</em> (use {@link #getPointerId(int)} to find the pointer
 896      * identifier for this index).
 897      * Whole numbers are pixels; the
 898      * value may have a fraction for input devices that are sub-pixel precise.
 899      * @param pointerIndex Raw index of pointer to retrieve.  Value may be from 0
 900      * (the first pointer that is down) to {@link #getPointerCount()}-1.
 901      */
 902     public final float getY(int pointerIndex) {
 903         return mDataSamples[mLastDataSampleIndex
 904                             + pointerIndex * NUM_SAMPLE_DATA + SAMPLE_Y] + mYOffset;
 905     }
 906
 907     /**
 908      * Returns the current pressure of this event for the given pointer
 909      * <em>index</em> (use {@link #getPointerId(int)} to find the pointer
 910      * identifier for this index).
 911      * The pressure generally
 912      * ranges from 0 (no pressure at all) to 1 (normal pressure), however
 913      * values higher than 1 may be generated depending on the calibration of
 914      * the input device.
 915      * @param pointerIndex Raw index of pointer to retrieve.  Value may be from 0
 916      * (the first pointer that is down) to {@link #getPointerCount()}-1.
 917      */
 918     public final float getPressure(int pointerIndex) {
 919         return mDataSamples[mLastDataSampleIndex
 920                             + pointerIndex * NUM_SAMPLE_DATA + SAMPLE_PRESSURE];
 921     }
 922
 923     /**
 924      * Returns a scaled value of the approximate size for the given pointer
 925      * <em>index</em> (use {@link #getPointerId(int)} to find the pointer
 926      * identifier for this index).
 927      * This represents some approximation of the area of the screen being
 928      * pressed; the actual value in pixels corresponding to the
 929      * touch is normalized with the device specific range of values
 930      * and scaled to a value between 0 and 1. The value of size can be used to
 931      * determine fat touch events.
 932      * @param pointerIndex Raw index of pointer to retrieve.  Value may be from 0
 933      * (the first pointer that is down) to {@link #getPointerCount()}-1.
 934      */
 935     public final float getSize(int pointerIndex) {
 936         return mDataSamples[mLastDataSampleIndex
 937                             + pointerIndex * NUM_SAMPLE_DATA + SAMPLE_SIZE];
 938     }
 939
 940     /**
 941      * Returns the length of the major axis of an ellipse that describes the touch
 942      * area at the point of contact for the given pointer
 943      * <em>index</em> (use {@link #getPointerId(int)} to find the pointer
 944      * identifier for this index).
 945      * @param pointerIndex Raw index of pointer to retrieve.  Value may be from 0
 946      * (the first pointer that is down) to {@link #getPointerCount()}-1.
 947      */
 948     public final float getTouchMajor(int pointerIndex) {
 949         return mDataSamples[mLastDataSampleIndex
 950                             + pointerIndex * NUM_SAMPLE_DATA + SAMPLE_TOUCH_MAJOR];
 951     }
 952
 953     /**
 954      * Returns the length of the minor axis of an ellipse that describes the touch
 955      * area at the point of contact for the given pointer
 956      * <em>index</em> (use {@link #getPointerId(int)} to find the pointer
 957      * identifier for this index).
 958      * @param pointerIndex Raw index of pointer to retrieve.  Value may be from 0
 959      * (the first pointer that is down) to {@link #getPointerCount()}-1.
 960      */
 961     public final float getTouchMinor(int pointerIndex) {
 962         return mDataSamples[mLastDataSampleIndex
 963                             + pointerIndex * NUM_SAMPLE_DATA + SAMPLE_TOUCH_MINOR];
 964     }
 965
 966     /**
 967      * Returns the length of the major axis of an ellipse that describes the size of
 968      * the approaching tool for the given pointer
 969      * <em>index</em> (use {@link #getPointerId(int)} to find the pointer
 970      * identifier for this index).
 971      * The tool area represents the estimated size of the finger or pen that is
 972      * touching the device independent of its actual touch area at the point of contact.
 973      * @param pointerIndex Raw index of pointer to retrieve.  Value may be from 0
 974      * (the first pointer that is down) to {@link #getPointerCount()}-1.
 975      */
 976     public final float getToolMajor(int pointerIndex) {
 977         return mDataSamples[mLastDataSampleIndex
 978                             + pointerIndex * NUM_SAMPLE_DATA + SAMPLE_TOOL_MAJOR];
 979     }
 980
 981     /**
 982      * Returns the length of the minor axis of an ellipse that describes the size of
 983      * the approaching tool for the given pointer
 984      * <em>index</em> (use {@link #getPointerId(int)} to find the pointer
 985      * identifier for this index).
 986      * The tool area represents the estimated size of the finger or pen that is
 987      * touching the device independent of its actual touch area at the point of contact.
 988      * @param pointerIndex Raw index of pointer to retrieve.  Value may be from 0
 989      * (the first pointer that is down) to {@link #getPointerCount()}-1.
 990      */
 991     public final float getToolMinor(int pointerIndex) {
 992         return mDataSamples[mLastDataSampleIndex
 993                             + pointerIndex * NUM_SAMPLE_DATA + SAMPLE_TOOL_MINOR];
 994     }
 995
 996     /**
 997      * Returns the orientation of the touch area and tool area in radians clockwise from vertical
 998      * for the given pointer <em>index</em> (use {@link #getPointerId(int)} to find the pointer
 999      * identifier for this index).
1000      * An angle of 0 degrees indicates that the major axis of contact is oriented
1001      * upwards, is perfectly circular or is of unknown orientation.  A positive angle
1002      * indicates that the major axis of contact is oriented to the right.  A negative angle
1003      * indicates that the major axis of contact is oriented to the left.
1004      * The full range is from -PI/2 radians (finger pointing fully left) to PI/2 radians
1005      * (finger pointing fully right).
1006      * @param pointerIndex Raw index of pointer to retrieve.  Value may be from 0
1007      * (the first pointer that is down) to {@link #getPointerCount()}-1.
1008      */
1009     public final float getOrientation(int pointerIndex) {
1010         return mDataSamples[mLastDataSampleIndex
1011                             + pointerIndex * NUM_SAMPLE_DATA + SAMPLE_ORIENTATION];
1012     }
1013
1014     /**
1015      * Populates a {@link PointerCoords} object with pointer coordinate data for
1016      * the specified pointer index.
1017      *
1018      * @param pointerIndex Raw index of pointer to retrieve.  Value may be from 0
1019      * (the first pointer that is down) to {@link #getPointerCount()}-1.
1020      * @param outPointerCoords The pointer coordinate object to populate.
1021      */
1022     public final void getPointerCoords(int pointerIndex, PointerCoords outPointerCoords) {
1023         final int sampleIndex = mLastDataSampleIndex + pointerIndex * NUM_SAMPLE_DATA;
1024         getPointerCoordsAtSampleIndex(sampleIndex, outPointerCoords);
1025     }
1026
1027     /**
1028      * Returns the state of any meta / modifier keys that were in effect when
1029      * the event was generated.  This is the same values as those
1030      * returned by {@link KeyEvent#getMetaState() KeyEvent.getMetaState}.
1031      *
1032      * @return an integer in which each bit set to 1 represents a pressed
1033      *         meta key
1034      *
1035      * @see KeyEvent#getMetaState()
1036      */
1037     public final int getMetaState() {
1038         return mMetaState;
1039     }
1040
1041     /**
1042      * Returns the original raw X coordinate of this event.  For touch
1043      * events on the screen, this is the original location of the event
1044      * on the screen, before it had been adjusted for the containing window
1045      * and views.
1046      */
1047     public final float getRawX() {
1048         return mDataSamples[mLastDataSampleIndex + SAMPLE_X];
1049     }
1050
1051     /**
1052      * Returns the original raw Y coordinate of this event.  For touch
1053      * events on the screen, this is the original location of the event
1054      * on the screen, before it had been adjusted for the containing window
1055      * and views.
1056      */
1057     public final float getRawY() {
1058         return mDataSamples[mLastDataSampleIndex + SAMPLE_Y];
1059     }
1060
1061     /**
1062      * Return the precision of the X coordinates being reported.  You can
1063      * multiple this number with {@link #getX} to find the actual hardware
1064      * value of the X coordinate.
1065      * @return Returns the precision of X coordinates being reported.
1066      */
1067     public final float getXPrecision() {
1068         return mXPrecision;
1069     }
1070
1071     /**
1072      * Return the precision of the Y coordinates being reported.  You can
1073      * multiple this number with {@link #getY} to find the actual hardware
1074      * value of the Y coordinate.
1075      * @return Returns the precision of Y coordinates being reported.
1076      */
1077     public final float getYPrecision() {
1078         return mYPrecision;
1079     }
1080
1081     /**
1082      * Returns the number of historical points in this event.  These are
1083      * movements that have occurred between this event and the previous event.
1084      * This only applies to ACTION_MOVE events -- all other actions will have
1085      * a size of 0.
1086      *
1087      * @return Returns the number of historical points in the event.
1088      */
1089     public final int getHistorySize() {
1090         return mLastEventTimeNanoSampleIndex;
1091     }
1092
1093     /**
1094      * Returns the time that a historical movement occurred between this event
1095      * and the previous event.  Only applies to ACTION_MOVE events.
1096      *
1097      * @param pos Which historical value to return; must be less than
1098      * {@link #getHistorySize}
1099      *
1100      * @see #getHistorySize
1101      * @see #getEventTime
1102      */
1103     public final long getHistoricalEventTime(int pos) {
1104         return mEventTimeNanoSamples[pos] / MS_PER_NS;
1105     }
1106
1107     /**
1108      * {@link #getHistoricalX(int)} for the first pointer index (may be an
1109      * arbitrary pointer identifier).
1110      */
1111     public final float getHistoricalX(int pos) {
1112         return mDataSamples[pos * mNumPointers * NUM_SAMPLE_DATA + SAMPLE_X] + mXOffset;
1113     }
1114
1115     /**
1116      * {@link #getHistoricalY(int)} for the first pointer index (may be an
1117      * arbitrary pointer identifier).
1118      */
1119     public final float getHistoricalY(int pos) {
1120         return mDataSamples[pos * mNumPointers * NUM_SAMPLE_DATA + SAMPLE_Y] + mYOffset;
1121     }
1122
1123     /**
1124      * {@link #getHistoricalPressure(int)} for the first pointer index (may be an
1125      * arbitrary pointer identifier).
1126      */
1127     public final float getHistoricalPressure(int pos) {
1128         return mDataSamples[pos * mNumPointers * NUM_SAMPLE_DATA + SAMPLE_PRESSURE];
1129     }
1130
1131     /**
1132      * {@link #getHistoricalSize(int)} for the first pointer index (may be an
1133      * arbitrary pointer identifier).
1134      */
1135     public final float getHistoricalSize(int pos) {
1136         return mDataSamples[pos * mNumPointers * NUM_SAMPLE_DATA + SAMPLE_SIZE];
1137     }
1138
1139     /**
1140      * {@link #getHistoricalTouchMajor(int)} for the first pointer index (may be an
1141      * arbitrary pointer identifier).
1142      */
1143     public final float getHistoricalTouchMajor(int pos) {
1144         return mDataSamples[pos * mNumPointers * NUM_SAMPLE_DATA + SAMPLE_TOUCH_MAJOR];
1145     }
1146
1147     /**
1148      * {@link #getHistoricalTouchMinor(int)} for the first pointer index (may be an
1149      * arbitrary pointer identifier).
1150      */
1151     public final float getHistoricalTouchMinor(int pos) {
1152         return mDataSamples[pos * mNumPointers * NUM_SAMPLE_DATA + SAMPLE_TOUCH_MINOR];
1153     }
1154
1155     /**
1156      * {@link #getHistoricalToolMajor(int)} for the first pointer index (may be an
1157      * arbitrary pointer identifier).
1158      */
1159     public final float getHistoricalToolMajor(int pos) {
1160         return mDataSamples[pos * mNumPointers * NUM_SAMPLE_DATA + SAMPLE_TOOL_MAJOR];
1161     }
1162
1163     /**
1164      * {@link #getHistoricalToolMinor(int)} for the first pointer index (may be an
1165      * arbitrary pointer identifier).
1166      */
1167     public final float getHistoricalToolMinor(int pos) {
1168         return mDataSamples[pos * mNumPointers * NUM_SAMPLE_DATA + SAMPLE_TOOL_MINOR];
1169     }
1170
1171     /**
1172      * {@link #getHistoricalOrientation(int)} for the first pointer index (may be an
1173      * arbitrary pointer identifier).
1174      */
1175     public final float getHistoricalOrientation(int pos) {
1176         return mDataSamples[pos * mNumPointers * NUM_SAMPLE_DATA + SAMPLE_ORIENTATION];
1177     }
1178
1179     /**
1180      * Returns a historical X coordinate, as per {@link #getX(int)}, that
1181      * occurred between this event and the previous event for the given pointer.
1182      * Only applies to ACTION_MOVE events.
1183      *
1184      * @param pointerIndex Raw index of pointer to retrieve.  Value may be from 0
1185      * (the first pointer that is down) to {@link #getPointerCount()}-1.
1186      * @param pos Which historical value to return; must be less than
1187      * {@link #getHistorySize}
1188      *
1189      * @see #getHistorySize
1190      * @see #getX
1191      */
1192     public final float getHistoricalX(int pointerIndex, int pos) {
1193         return mDataSamples[(pos * mNumPointers + pointerIndex)
1194                             * NUM_SAMPLE_DATA + SAMPLE_X] + mXOffset;
1195     }
1196
1197     /**
1198      * Returns a historical Y coordinate, as per {@link #getY(int)}, that
1199      * occurred between this event and the previous event for the given pointer.
1200      * Only applies to ACTION_MOVE events.
1201      *
1202      * @param pointerIndex Raw index of pointer to retrieve.  Value may be from 0
1203      * (the first pointer that is down) to {@link #getPointerCount()}-1.
1204      * @param pos Which historical value to return; must be less than
1205      * {@link #getHistorySize}
1206      *
1207      * @see #getHistorySize
1208      * @see #getY
1209      */
1210     public final float getHistoricalY(int pointerIndex, int pos) {
1211         return mDataSamples[(pos * mNumPointers + pointerIndex)
1212                             * NUM_SAMPLE_DATA + SAMPLE_Y] + mYOffset;
1213     }
1214
1215     /**
1216      * Returns a historical pressure coordinate, as per {@link #getPressure(int)},
1217      * that occurred between this event and the previous event for the given
1218      * pointer.  Only applies to ACTION_MOVE events.
1219      *
1220      * @param pointerIndex Raw index of pointer to retrieve.  Value may be from 0
1221      * (the first pointer that is down) to {@link #getPointerCount()}-1.
1222      * @param pos Which historical value to return; must be less than
1223      * {@link #getHistorySize}
1224      *
1225      * @see #getHistorySize
1226      * @see #getPressure
1227      */
1228     public final float getHistoricalPressure(int pointerIndex, int pos) {
1229         return mDataSamples[(pos * mNumPointers + pointerIndex)
1230                             * NUM_SAMPLE_DATA + SAMPLE_PRESSURE];
1231     }
1232
1233     /**
1234      * Returns a historical size coordinate, as per {@link #getSize(int)}, that
1235      * occurred between this event and the previous event for the given pointer.
1236      * Only applies to ACTION_MOVE events.
1237      *
1238      * @param pointerIndex Raw index of pointer to retrieve.  Value may be from 0
1239      * (the first pointer that is down) to {@link #getPointerCount()}-1.
1240      * @param pos Which historical value to return; must be less than
1241      * {@link #getHistorySize}
1242      *
1243      * @see #getHistorySize
1244      * @see #getSize
1245      */
1246     public final float getHistoricalSize(int pointerIndex, int pos) {
1247         return mDataSamples[(pos * mNumPointers + pointerIndex)
1248                             * NUM_SAMPLE_DATA + SAMPLE_SIZE];
1249     }
1250
1251     /**
1252      * Returns a historical touch major axis coordinate, as per {@link #getTouchMajor(int)}, that
1253      * occurred between this event and the previous event for the given pointer.
1254      * Only applies to ACTION_MOVE events.
1255      *
1256      * @param pointerIndex Raw index of pointer to retrieve.  Value may be from 0
1257      * (the first pointer that is down) to {@link #getPointerCount()}-1.
1258      * @param pos Which historical value to return; must be less than
1259      * {@link #getHistorySize}
1260      *
1261      * @see #getHistorySize
1262      * @see #getTouchMajor
1263      */
1264     public final float getHistoricalTouchMajor(int pointerIndex, int pos) {
1265         return mDataSamples[(pos * mNumPointers + pointerIndex)
1266                             * NUM_SAMPLE_DATA + SAMPLE_TOUCH_MAJOR];
1267     }
1268
1269     /**
1270      * Returns a historical touch minor axis coordinate, as per {@link #getTouchMinor(int)}, that
1271      * occurred between this event and the previous event for the given pointer.
1272      * Only applies to ACTION_MOVE events.
1273      *
1274      * @param pointerIndex Raw index of pointer to retrieve.  Value may be from 0
1275      * (the first pointer that is down) to {@link #getPointerCount()}-1.
1276      * @param pos Which historical value to return; must be less than
1277      * {@link #getHistorySize}
1278      *
1279      * @see #getHistorySize
1280      * @see #getTouchMinor
1281      */
1282     public final float getHistoricalTouchMinor(int pointerIndex, int pos) {
1283         return mDataSamples[(pos * mNumPointers + pointerIndex)
1284                             * NUM_SAMPLE_DATA + SAMPLE_TOUCH_MINOR];
1285     }
1286
1287     /**
1288      * Returns a historical tool major axis coordinate, as per {@link #getToolMajor(int)}, that
1289      * occurred between this event and the previous event for the given pointer.
1290      * Only applies to ACTION_MOVE events.
1291      *
1292      * @param pointerIndex Raw index of pointer to retrieve.  Value may be from 0
1293      * (the first pointer that is down) to {@link #getPointerCount()}-1.
1294      * @param pos Which historical value to return; must be less than
1295      * {@link #getHistorySize}
1296      *
1297      * @see #getHistorySize
1298      * @see #getToolMajor
1299      */
1300     public final float getHistoricalToolMajor(int pointerIndex, int pos) {
1301         return mDataSamples[(pos * mNumPointers + pointerIndex)
1302                             * NUM_SAMPLE_DATA + SAMPLE_TOOL_MAJOR];
1303     }
1304
1305     /**
1306      * Returns a historical tool minor axis coordinate, as per {@link #getToolMinor(int)}, that
1307      * occurred between this event and the previous event for the given pointer.
1308      * Only applies to ACTION_MOVE events.
1309      *
1310      * @param pointerIndex Raw index of pointer to retrieve.  Value may be from 0
1311      * (the first pointer that is down) to {@link #getPointerCount()}-1.
1312      * @param pos Which historical value to return; must be less than
1313      * {@link #getHistorySize}
1314      *
1315      * @see #getHistorySize
1316      * @see #getToolMinor
1317      */
1318     public final float getHistoricalToolMinor(int pointerIndex, int pos) {
1319         return mDataSamples[(pos * mNumPointers + pointerIndex)
1320                             * NUM_SAMPLE_DATA + SAMPLE_TOOL_MINOR];
1321     }
1322
1323     /**
1324      * Returns a historical orientation coordinate, as per {@link #getOrientation(int)}, that
1325      * occurred between this event and the previous event for the given pointer.
1326      * Only applies to ACTION_MOVE events.
1327      *
1328      * @param pointerIndex Raw index of pointer to retrieve.  Value may be from 0
1329      * (the first pointer that is down) to {@link #getPointerCount()}-1.
1330      * @param pos Which historical value to return; must be less than
1331      * {@link #getHistorySize}
1332      *
1333      * @see #getHistorySize
1334      * @see #getOrientation
1335      */
1336     public final float getHistoricalOrientation(int pointerIndex, int pos) {
1337         return mDataSamples[(pos * mNumPointers + pointerIndex)
1338                             * NUM_SAMPLE_DATA + SAMPLE_ORIENTATION];
1339     }
1340
1341     /**
1342      * Populates a {@link PointerCoords} object with historical pointer coordinate data,
1343      * as per {@link #getPointerCoords}, that occurred between this event and the previous
1344      * event for the given pointer.
1345      * Only applies to ACTION_MOVE events.
1346      *
1347      * @param pointerIndex Raw index of pointer to retrieve.  Value may be from 0
1348      * (the first pointer that is down) to {@link #getPointerCount()}-1.
1349      * @param pos Which historical value to return; must be less than
1350      * {@link #getHistorySize}
1351      * @param outPointerCoords The pointer coordinate object to populate.
1352      *
1353      * @see #getHistorySize
1354      * @see #getPointerCoords
1355      */
1356     public final void getHistoricalPointerCoords(int pointerIndex, int pos,
1357             PointerCoords outPointerCoords) {
1358         final int sampleIndex = (pos * mNumPointers + pointerIndex) * NUM_SAMPLE_DATA;
1359         getPointerCoordsAtSampleIndex(sampleIndex, outPointerCoords);
1360     }
1361
1362     /**
1363      * Returns a bitfield indicating which edges, if any, were touched by this
1364      * MotionEvent. For touch events, clients can use this to determine if the
1365      * user's finger was touching the edge of the display.
1366      *
1367      * @see #EDGE_LEFT
1368      * @see #EDGE_TOP
1369      * @see #EDGE_RIGHT
1370      * @see #EDGE_BOTTOM
1371      */
1372     public final int getEdgeFlags() {
1373         return mEdgeFlags;
1374     }
1375
1376
1377     /**
1378      * Sets the bitfield indicating which edges, if any, were touched by this
1379      * MotionEvent.
1380      *
1381      * @see #getEdgeFlags()
1382      */
1383     public final void setEdgeFlags(int flags) {
1384         mEdgeFlags = flags;
1385     }
1386
1387     /**
1388      * Sets this event's action.
1389      */
1390     public final void setAction(int action) {
1391         mAction = action;
1392     }
1393
1394     /**
1395      * Adjust this event's location.
1396      * @param deltaX Amount to add to the current X coordinate of the event.
1397      * @param deltaY Amount to add to the current Y coordinate of the event.
1398      */
1399     public final void offsetLocation(float deltaX, float deltaY) {
1400         mXOffset += deltaX;
1401         mYOffset += deltaY;
1402     }
1403
1404     /**
1405      * Set this event's location.  Applies {@link #offsetLocation} with a
1406      * delta from the current location to the given new location.
1407      *
1408      * @param x New absolute X location.
1409      * @param y New absolute Y location.
1410      */
1411     public final void setLocation(float x, float y) {
1412         final float[] dataSamples = mDataSamples;
1413         final int lastDataSampleIndex = mLastDataSampleIndex;
1414         mXOffset = x - dataSamples[lastDataSampleIndex + SAMPLE_X];
1415         mYOffset = y - dataSamples[lastDataSampleIndex + SAMPLE_Y];
1416     }
1417
1418     private final void getPointerCoordsAtSampleIndex(int sampleIndex,
1419             PointerCoords outPointerCoords) {
1420         final float[] dataSamples = mDataSamples;
1421         outPointerCoords.x = dataSamples[sampleIndex + SAMPLE_X] + mXOffset;
1422         outPointerCoords.y = dataSamples[sampleIndex + SAMPLE_Y] + mYOffset;
1423         outPointerCoords.pressure = dataSamples[sampleIndex + SAMPLE_PRESSURE];
1424         outPointerCoords.size = dataSamples[sampleIndex + SAMPLE_SIZE];
1425         outPointerCoords.touchMajor = dataSamples[sampleIndex + SAMPLE_TOUCH_MAJOR];
1426         outPointerCoords.touchMinor = dataSamples[sampleIndex + SAMPLE_TOUCH_MINOR];
1427         outPointerCoords.toolMajor = dataSamples[sampleIndex + SAMPLE_TOOL_MAJOR];
1428         outPointerCoords.toolMinor = dataSamples[sampleIndex + SAMPLE_TOOL_MINOR];
1429         outPointerCoords.orientation = dataSamples[sampleIndex + SAMPLE_ORIENTATION];
1430     }
1431
1432     private final void setPointerCoordsAtSampleIndex(int sampleIndex,
1433             PointerCoords[] pointerCoords) {
1434         final int numPointers = mNumPointers;
1435         for (int i = 0; i < numPointers; i++) {
1436             setPointerCoordsAtSampleIndex(sampleIndex, pointerCoords[i]);
1437             sampleIndex += NUM_SAMPLE_DATA;
1438         }
1439     }
1440
1441     private final void setPointerCoordsAtSampleIndex(int sampleIndex,
1442             PointerCoords pointerCoords) {
1443         final float[] dataSamples = mDataSamples;
1444         dataSamples[sampleIndex + SAMPLE_X] = pointerCoords.x - mXOffset;
1445         dataSamples[sampleIndex + SAMPLE_Y] = pointerCoords.y - mYOffset;
1446         dataSamples[sampleIndex + SAMPLE_PRESSURE] = pointerCoords.pressure;
1447         dataSamples[sampleIndex + SAMPLE_SIZE] = pointerCoords.size;
1448         dataSamples[sampleIndex + SAMPLE_TOUCH_MAJOR] = pointerCoords.touchMajor;
1449         dataSamples[sampleIndex + SAMPLE_TOUCH_MINOR] = pointerCoords.touchMinor;
1450         dataSamples[sampleIndex + SAMPLE_TOOL_MAJOR] = pointerCoords.toolMajor;
1451         dataSamples[sampleIndex + SAMPLE_TOOL_MINOR] = pointerCoords.toolMinor;
1452         dataSamples[sampleIndex + SAMPLE_ORIENTATION] = pointerCoords.orientation;
1453     }
1454
1455     private final void setPointerCoordsAtSampleIndex(int sampleIndex,
1456             float x, float y, float pressure, float size) {
1457         final float[] dataSamples = mDataSamples;
1458         dataSamples[sampleIndex + SAMPLE_X] = x - mXOffset;
1459         dataSamples[sampleIndex + SAMPLE_Y] = y - mYOffset;
1460         dataSamples[sampleIndex + SAMPLE_PRESSURE] = pressure;
1461         dataSamples[sampleIndex + SAMPLE_SIZE] = size;
1462         dataSamples[sampleIndex + SAMPLE_TOUCH_MAJOR] = pressure;
1463         dataSamples[sampleIndex + SAMPLE_TOUCH_MINOR] = pressure;
1464         dataSamples[sampleIndex + SAMPLE_TOOL_MAJOR] = size;
1465         dataSamples[sampleIndex + SAMPLE_TOOL_MINOR] = size;
1466         dataSamples[sampleIndex + SAMPLE_ORIENTATION] = 0;
1467     }
1468
1469     private final void incrementNumSamplesAndReserveStorage(int dataSampleStride) {
1470         if (mNumSamples == mEventTimeNanoSamples.length) {
1471             long[] newEventTimeNanoSamples = new long[mNumSamples + BASE_AVAIL_SAMPLES];
1472             System.arraycopy(mEventTimeNanoSamples, 0, newEventTimeNanoSamples, 0, mNumSamples);
1473             mEventTimeNanoSamples = newEventTimeNanoSamples;
1474         }
1475
1476         int nextDataSampleIndex = mLastDataSampleIndex + dataSampleStride;
1477         if (nextDataSampleIndex + dataSampleStride > mDataSamples.length) {
1478             float[] newDataSamples = new float[nextDataSampleIndex
1479                                                + BASE_AVAIL_SAMPLES * dataSampleStride];
1480             System.arraycopy(mDataSamples, 0, newDataSamples, 0, nextDataSampleIndex);
1481             mDataSamples = newDataSamples;
1482         }
1483
1484         mLastEventTimeNanoSampleIndex = mNumSamples;
1485         mLastDataSampleIndex = nextDataSampleIndex;
1486         mNumSamples += 1;
1487     }
1488
1489     /**
1490      * Add a new movement to the batch of movements in this event.  The event's
1491      * current location, position and size is updated to the new values.
1492      * The current values in the event are added to a list of historical values.
1493      *
1494      * Only applies to {@link #ACTION_MOVE} events.
1495      *
1496      * @param eventTime The time stamp (in ms) for this data.
1497      * @param x The new X position.
1498      * @param y The new Y position.
1499      * @param pressure The new pressure.
1500      * @param size The new size.
1501      * @param metaState Meta key state.
1502      */
1503     public final void addBatch(long eventTime, float x, float y,
1504             float pressure, float size, int metaState) {
1505         incrementNumSamplesAndReserveStorage(NUM_SAMPLE_DATA);
1506
1507         mEventTimeNanoSamples[mLastEventTimeNanoSampleIndex] = eventTime * MS_PER_NS;
1508         setPointerCoordsAtSampleIndex(mLastDataSampleIndex, x, y, pressure, size);
1509
1510         mMetaState |= metaState;
1511     }
1512
1513     /**
1514      * Add a new movement to the batch of movements in this event.  The event's
1515      * current location, position and size is updated to the new values.
1516      * The current values in the event are added to a list of historical values.
1517      *
1518      * Only applies to {@link #ACTION_MOVE} events.
1519      *
1520      * @param eventTime The time stamp (in ms) for this data.
1521      * @param pointerCoords The new pointer coordinates.
1522      * @param metaState Meta key state.
1523      */
1524     public final void addBatch(long eventTime, PointerCoords[] pointerCoords, int metaState) {
1525         final int dataSampleStride = mNumPointers * NUM_SAMPLE_DATA;
1526         incrementNumSamplesAndReserveStorage(dataSampleStride);
1527
1528         mEventTimeNanoSamples[mLastEventTimeNanoSampleIndex] = eventTime * MS_PER_NS;
1529         setPointerCoordsAtSampleIndex(mLastDataSampleIndex, pointerCoords);
1530
1531         mMetaState |= metaState;
1532     }
1533
1534     @Override
1535     public String toString() {
1536         return "MotionEvent{" + Integer.toHexString(System.identityHashCode(this))
1537             + " action=" + mAction + " x=" + getX()
1538             + " y=" + getY() + " pressure=" + getPressure() + " size=" + getSize() + "}";
1539     }
1540
1541     public static final Parcelable.Creator<MotionEvent> CREATOR
1542             = new Parcelable.Creator<MotionEvent>() {
1543         public MotionEvent createFromParcel(Parcel in) {
1544             in.readInt(); // skip token, we already know this is a MotionEvent
1545             return MotionEvent.createFromParcelBody(in);
1546         }
1547
1548         public MotionEvent[] newArray(int size) {
1549             return new MotionEvent[size];
1550         }
1551     };
1552
1553     /** @hide */
1554     public static MotionEvent createFromParcelBody(Parcel in) {
1555         final int NP = in.readInt();
1556         final int NS = in.readInt();
1557         final int NI = NP * NS * NUM_SAMPLE_DATA;
1558
1559         MotionEvent ev = obtain(NP, NS);
1560         ev.mNumPointers = NP;
1561         ev.mNumSamples = NS;
1562
1563         ev.readBaseFromParcel(in);
1564
1565         ev.mDownTimeNano = in.readLong();
1566         ev.mAction = in.readInt();
1567         ev.mXOffset = in.readFloat();
1568         ev.mYOffset = in.readFloat();
1569         ev.mXPrecision = in.readFloat();
1570         ev.mYPrecision = in.readFloat();
1571         ev.mEdgeFlags = in.readInt();
1572         ev.mMetaState = in.readInt();
1573         ev.mFlags = in.readInt();
1574
1575         final int[] pointerIdentifiers = ev.mPointerIdentifiers;
1576         for (int i = 0; i < NP; i++) {
1577             pointerIdentifiers[i] = in.readInt();
1578         }
1579
1580         final long[] eventTimeNanoSamples = ev.mEventTimeNanoSamples;
1581         for (int i = 0; i < NS; i++) {
1582             eventTimeNanoSamples[i] = in.readLong();
1583         }
1584
1585         final float[] dataSamples = ev.mDataSamples;
1586         for (int i = 0; i < NI; i++) {
1587             dataSamples[i] = in.readFloat();
1588         }
1589
1590         ev.mLastEventTimeNanoSampleIndex = NS - 1;
1591         ev.mLastDataSampleIndex = (NS - 1) * NP * NUM_SAMPLE_DATA;
1592         return ev;
1593     }
1594
1595     public void writeToParcel(Parcel out, int flags) {
1596         out.writeInt(PARCEL_TOKEN_MOTION_EVENT);
1597
1598         final int NP = mNumPointers;
1599         final int NS = mNumSamples;
1600         final int NI = NP * NS * NUM_SAMPLE_DATA;
1601
1602         out.writeInt(NP);
1603         out.writeInt(NS);
1604
1605         writeBaseToParcel(out);
1606
1607         out.writeLong(mDownTimeNano);
1608         out.writeInt(mAction);
1609         out.writeFloat(mXOffset);
1610         out.writeFloat(mYOffset);
1611         out.writeFloat(mXPrecision);
1612         out.writeFloat(mYPrecision);
1613         out.writeInt(mEdgeFlags);
1614         out.writeInt(mMetaState);
1615         out.writeInt(mFlags);
1616
1617         final int[] pointerIdentifiers = mPointerIdentifiers;
1618         for (int i = 0; i < NP; i++) {
1619             out.writeInt(pointerIdentifiers[i]);
1620         }
1621
1622         final long[] eventTimeNanoSamples = mEventTimeNanoSamples;
1623         for (int i = 0; i < NS; i++) {
1624             out.writeLong(eventTimeNanoSamples[i]);
1625         }
1626
1627         final float[] dataSamples = mDataSamples;
1628         for (int i = 0; i < NI; i++) {
1629             out.writeFloat(dataSamples[i]);
1630         }
1631     }
1632
1633     /**
1634      * Transfer object for pointer coordinates.
1635      *
1636      * Objects of this type can be used to manufacture new {@link MotionEvent} objects
1637      * and to query pointer coordinate information in bulk.
1638      *
1639      * Refer to {@link InputDevice} for information about how different kinds of
1640      * input devices and sources represent pointer coordinates.
1641      */
1642     public static final class PointerCoords {
1643         /**
1644          * The X coordinate of the pointer movement.
1645          * The interpretation varies by input source and may represent the position of
1646          * the center of the contact area, a relative displacement in device-specific units
1647          * or something else.
1648          */
1649         public float x;
1650
1651         /**
1652          * The Y coordinate of the pointer movement.
1653          * The interpretation varies by input source and may represent the position of
1654          * the center of the contact area, a relative displacement in device-specific units
1655          * or something else.
1656          */
1657         public float y;
1658
1659         /**
1660          * A scaled value that describes the pressure applied to the pointer.
1661          * The pressure generally ranges from 0 (no pressure at all) to 1 (normal pressure),
1662          * however values higher than 1 may be generated depending on the calibration of
1663          * the input device.
1664          */
1665         public float pressure;
1666
1667         /**
1668          * A scaled value of the approximate size of the pointer touch area.
1669          * This represents some approximation of the area of the screen being
1670          * pressed; the actual value in pixels corresponding to the
1671          * touch is normalized with the device specific range of values
1672          * and scaled to a value between 0 and 1. The value of size can be used to
1673          * determine fat touch events.
1674          */
1675         public float size;
1676
1677         /**
1678          * The length of the major axis of an ellipse that describes the touch area at
1679          * the point of contact.
1680          */
1681         public float touchMajor;
1682
1683         /**
1684          * The length of the minor axis of an ellipse that describes the touch area at
1685          * the point of contact.
1686          */
1687         public float touchMinor;
1688
1689         /**
1690          * The length of the major axis of an ellipse that describes the size of
1691          * the approaching tool.
1692          * The tool area represents the estimated size of the finger or pen that is
1693          * touching the device independent of its actual touch area at the point of contact.
1694          */
1695         public float toolMajor;
1696
1697         /**
1698          * The length of the minor axis of an ellipse that describes the size of
1699          * the approaching tool.
1700          * The tool area represents the estimated size of the finger or pen that is
1701          * touching the device independent of its actual touch area at the point of contact.
1702          */
1703         public float toolMinor;
1704
1705         /**
1706          * The orientation of the touch area and tool area in radians clockwise from vertical.
1707          * An angle of 0 degrees indicates that the major axis of contact is oriented
1708          * upwards, is perfectly circular or is of unknown orientation.  A positive angle
1709          * indicates that the major axis of contact is oriented to the right.  A negative angle
1710          * indicates that the major axis of contact is oriented to the left.
1711          * The full range is from -PI/2 radians (finger pointing fully left) to PI/2 radians
1712          * (finger pointing fully right).
1713          */
1714         public float orientation;
1715
1716         /*
1717         private static final float PI_4 = (float) (Math.PI / 4);
1718
1719         public float getTouchWidth() {
1720             return Math.abs(orientation) > PI_4 ? touchMajor : touchMinor;
1721         }
1722
1723         public float getTouchHeight() {
1724             return Math.abs(orientation) > PI_4 ? touchMinor : touchMajor;
1725         }
1726
1727         public float getToolWidth() {
1728             return Math.abs(orientation) > PI_4 ? toolMajor : toolMinor;
1729         }
1730
1731         public float getToolHeight() {
1732             return Math.abs(orientation) > PI_4 ? toolMinor : toolMajor;
1733         }
1734         */
1735     }
1736 }