android-35/android/view/MotionEvent.java - platform/prebuilts/fullsdk/sources - Git at Google

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

 package android.view;

 import static android.os.IInputConstants.INPUT_EVENT_FLAG_CANCELED;
 import static android.os.IInputConstants.MOTION_EVENT_FLAG_HOVER_EXIT_PENDING;
 import static android.os.IInputConstants.INPUT_EVENT_FLAG_IS_ACCESSIBILITY_EVENT;
 import static android.os.IInputConstants.MOTION_EVENT_FLAG_IS_GENERATED_GESTURE;
 import static android.os.IInputConstants.MOTION_EVENT_FLAG_NO_FOCUS_CHANGE;
 import static android.os.IInputConstants.INPUT_EVENT_FLAG_TAINTED;
 import static android.os.IInputConstants.MOTION_EVENT_FLAG_TARGET_ACCESSIBILITY_FOCUS;
 import static android.os.IInputConstants.MOTION_EVENT_FLAG_WINDOW_IS_OBSCURED;
 import static android.os.IInputConstants.MOTION_EVENT_FLAG_WINDOW_IS_PARTIALLY_OBSCURED;
 import static android.view.Display.DEFAULT_DISPLAY;

 import static java.lang.annotation.RetentionPolicy.SOURCE;

 import android.annotation.FlaggedApi;
 import android.annotation.IntDef;
 import android.annotation.NonNull;
 import android.annotation.Nullable;
 import android.annotation.SuppressLint;
 import android.annotation.TestApi;
 import android.compat.annotation.UnsupportedAppUsage;
 import android.graphics.Matrix;
 import android.os.Build;
 import android.os.Parcel;
 import android.os.Parcelable;
 import android.os.SystemClock;
 import android.util.Log;
 import android.util.SparseArray;

 import com.android.hardware.input.Flags;

 import dalvik.annotation.optimization.CriticalNative;
 import dalvik.annotation.optimization.FastNative;

 import java.lang.annotation.Retention;
 import java.util.Objects;

 /**
  * Object used to report movement (mouse, pen, finger, trackball) events.
  * Motion events may hold either absolute or relative movements and other data,
  * depending on the type of device.
  *
  * <h3>Overview</h3>
  * <p>
  * Motion events describe movements in terms of an action code and a set of axis values.
  * The action code specifies the state change that occurred such as a pointer going
  * down or up.  The axis values describe the position and other movement properties.
  * </p><p>
  * For example, when the user first touches the screen, the system delivers a touch
  * event to the appropriate {@link View} with the action code {@link #ACTION_DOWN}
  * and a set of axis values that include the X and Y coordinates of the touch and
  * information about the pressure, size and orientation of the contact area.
  * </p><p>
  * Some devices can report multiple movement traces at the same time.  Multi-touch
  * screens emit one movement trace for each finger.  The individual fingers or
  * other objects that generate movement traces are referred to as <em>pointers</em>.
  * Motion events contain information about all of the pointers that are currently active
  * even if some of them have not moved since the last event was delivered.
  * </p><p>
  * The number of pointers only ever changes by one as individual pointers go up and down,
  * except when the gesture is canceled.
  * </p><p>
  * Each pointer has a unique id that is assigned when it first goes down
  * (indicated by {@link #ACTION_DOWN} or {@link #ACTION_POINTER_DOWN}).  A pointer id
  * remains valid until the pointer eventually goes up (indicated by {@link #ACTION_UP}
  * or {@link #ACTION_POINTER_UP}) or when the gesture is canceled (indicated by
  * {@link #ACTION_CANCEL}).
  * </p><p>
  * The MotionEvent class provides many methods to query the position and other properties of
  * pointers, such as {@link #getX(int)}, {@link #getY(int)}, {@link #getAxisValue},
  * {@link #getPointerId(int)}, {@link #getToolType(int)}, and many others.  Most of these
  * methods accept the pointer index as a parameter rather than the pointer id.
  * The pointer index of each pointer in the event ranges from 0 to one less than the value
  * returned by {@link #getPointerCount()}.
  * </p><p>
  * The order in which individual pointers appear within a motion event is undefined.
  * Thus the pointer index of a pointer can change from one event to the next but
  * the pointer id of a pointer is guaranteed to remain constant as long as the pointer
  * remains active.  Use the {@link #getPointerId(int)} method to obtain the
  * pointer id of a pointer to track it across all subsequent motion events in a gesture.
  * Then for successive motion events, use the {@link #findPointerIndex(int)} method
  * to obtain the pointer index for a given pointer id in that motion event.
  * </p><p>
  * Mouse and stylus buttons can be retrieved using {@link #getButtonState()}.  It is a
  * good idea to check the button state while handling {@link #ACTION_DOWN} as part
  * of a touch event.  The application may choose to perform some different action
  * if the touch event starts due to a secondary button click, such as presenting a
  * context menu.
  * </p>
  *
  * <h3>Batching</h3>
  * <p>
  * For efficiency, motion events with {@link #ACTION_MOVE} may batch together
  * multiple movement samples within a single object.  The most current
  * pointer coordinates are available using {@link #getX(int)} and {@link #getY(int)}.
  * Earlier coordinates within the batch are accessed using {@link #getHistoricalX(int, int)}
  * and {@link #getHistoricalY(int, int)}.  The coordinates are "historical" only
  * insofar as they are older than the current coordinates in the batch; however,
  * they are still distinct from any other coordinates reported in prior motion events.
  * To process all coordinates in the batch in time order, first consume the historical
  * coordinates then consume the current coordinates.
  * </p><p>
  * Example: Consuming all samples for all pointers in a motion event in time order.
  * </p><p><pre><code>
  * void printSamples(MotionEvent ev) {
  *     final int historySize = ev.getHistorySize();
  *     final int pointerCount = ev.getPointerCount();
  *     for (int h = 0; h &lt; historySize; h++) {
  *         System.out.printf("At time %d:", ev.getHistoricalEventTime(h));
  *         for (int p = 0; p &lt; pointerCount; p++) {
  *             System.out.printf("  pointer %d: (%f,%f)",
  *                 ev.getPointerId(p), ev.getHistoricalX(p, h), ev.getHistoricalY(p, h));
  *         }
  *     }
  *     System.out.printf("At time %d:", ev.getEventTime());
  *     for (int p = 0; p &lt; pointerCount; p++) {
  *         System.out.printf("  pointer %d: (%f,%f)",
  *             ev.getPointerId(p), ev.getX(p), ev.getY(p));
  *     }
  * }
  * </code></pre></p>
  *
  * <h3>Device Types</h3>
  * <p>
  * The interpretation of the contents of a MotionEvent varies significantly depending
  * on the source class of the device.
  * </p><p>
  * On pointing devices with source class {@link InputDevice#SOURCE_CLASS_POINTER}
  * such as touch screens, the pointer coordinates specify absolute
  * positions such as view X/Y coordinates.  Each complete gesture is represented
  * by a sequence of motion events with actions that describe pointer state transitions
  * and movements.  A gesture starts with a motion event with {@link #ACTION_DOWN}
  * that provides the location of the first pointer down.  As each additional
  * pointer that goes down or up, the framework will generate a motion event with
  * {@link #ACTION_POINTER_DOWN} or {@link #ACTION_POINTER_UP} accordingly.
  * Pointer movements are described by motion events with {@link #ACTION_MOVE}.
  * Finally, a gesture end either when the final pointer goes up as represented
  * by a motion event with {@link #ACTION_UP} or when gesture is canceled
  * with {@link #ACTION_CANCEL}.
  * </p><p>
  * Some pointing devices such as mice may support vertical and/or horizontal scrolling.
  * A scroll event is reported as a generic motion event with {@link #ACTION_SCROLL} that
  * includes the relative scroll offset in the {@link #AXIS_VSCROLL} and
  * {@link #AXIS_HSCROLL} axes.  See {@link #getAxisValue(int)} for information
  * about retrieving these additional axes.
  * </p><p>
  * On trackball devices with source class {@link InputDevice#SOURCE_CLASS_TRACKBALL},
  * the pointer coordinates specify relative movements as X/Y deltas.
  * A trackball gesture consists of a sequence of movements described by motion
  * events with {@link #ACTION_MOVE} interspersed with occasional {@link #ACTION_DOWN}
  * or {@link #ACTION_UP} motion events when the trackball button is pressed or released.
  * </p><p>
  * On joystick devices with source class {@link InputDevice#SOURCE_CLASS_JOYSTICK},
  * the pointer coordinates specify the absolute position of the joystick axes.
  * The joystick axis values are normalized to a range of -1.0 to 1.0 where 0.0 corresponds
  * to the center position.  More information about the set of available axes and the
  * range of motion can be obtained using {@link InputDevice#getMotionRange}.
  * Some common joystick axes are {@link #AXIS_X}, {@link #AXIS_Y},
  * {@link #AXIS_HAT_X}, {@link #AXIS_HAT_Y}, {@link #AXIS_Z} and {@link #AXIS_RZ}.
  * </p><p>
  * Refer to {@link InputDevice} for more information about how different kinds of
  * input devices and sources represent pointer coordinates.
  * </p>
  *
  * <h3>Consistency Guarantees</h3>
  * <p>
  * Motion events are always delivered to views as a consistent stream of events.
  * What constitutes a consistent stream varies depending on the type of device.
  * For touch events, consistency implies that pointers go down one at a time,
  * move around as a group and then go up one at a time or are canceled.
  * </p><p>
  * While the framework tries to deliver consistent streams of motion events to
  * views, it cannot guarantee it.  Some events may be dropped or modified by
  * containing views in the application before they are delivered thereby making
  * the stream of events inconsistent.  Views should always be prepared to
  * handle {@link #ACTION_CANCEL} and should tolerate anomalous
  * situations such as receiving a new {@link #ACTION_DOWN} without first having
  * received an {@link #ACTION_UP} for the prior gesture.
  * </p>
  */
 public final class MotionEvent extends InputEvent implements Parcelable {
     private static final String TAG = "MotionEvent";
     private static final long NS_PER_MS = 1000000;
     private static final String LABEL_PREFIX = "AXIS_";

     private static final boolean DEBUG_CONCISE_TOSTRING = false;

     /**
      * An invalid pointer id.
      *
      * This value (-1) can be used as a placeholder to indicate that a pointer id
      * has not been assigned or is not available.  It cannot appear as
      * a pointer id inside a {@link MotionEvent}.
      */
     public static final int INVALID_POINTER_ID = -1;

     /**
      * Bit mask of the parts of the action code that are the action itself.
      */
     public static final int ACTION_MASK             = 0xff;

     /**
      * Constant for {@link #getActionMasked}: A pressed gesture has started, the
      * motion contains the initial starting location.
      * <p>
      * This is also a good time to check the button state to distinguish
      * secondary and tertiary button clicks and handle them appropriately.
      * Use {@link #getButtonState} to retrieve the button state.
      * </p>
      */
     public static final int ACTION_DOWN             = 0;

     /**
      * Constant for {@link #getActionMasked}: A pressed gesture has finished, the
      * motion contains the final release location as well as any intermediate
      * points since the last down or move event.
      */
     public static final int ACTION_UP               = 1;

     /**
      * Constant for {@link #getActionMasked}: A change has happened during a
      * press gesture (between {@link #ACTION_DOWN} and {@link #ACTION_UP}).
      * The motion contains the most recent point, as well as any intermediate
      * points since the last down or move event.
      */
     public static final int ACTION_MOVE             = 2;

     /**
      * Constant for {@link #getActionMasked}: The current gesture has been aborted.
      * You will not receive any more points in it.  You should treat this as
      * an up event, but not perform any action that you normally would.
      */
     public static final int ACTION_CANCEL           = 3;

     /**
      * Constant for {@link #getActionMasked}: A movement has happened outside of the
      * normal bounds of the UI element.  This does not provide a full gesture,
      * but only the initial location of the movement/touch.
      * <p>
      * Note: Because the location of any event will be outside the
      * bounds of the view hierarchy, it will not get dispatched to
      * any children of a ViewGroup by default. Therefore,
      * movements with ACTION_OUTSIDE should be handled in either the
      * root {@link View} or in the appropriate {@link Window.Callback}
      * (e.g. {@link android.app.Activity} or {@link android.app.Dialog}).
      * </p>
      */
     public static final int ACTION_OUTSIDE          = 4;

     /**
      * Constant for {@link #getActionMasked}: A non-primary pointer has gone down.
      * <p>
      * Use {@link #getActionIndex} to retrieve the index of the pointer that changed.
      * </p><p>
      * The index is encoded in the {@link #ACTION_POINTER_INDEX_MASK} bits of the
      * unmasked action returned by {@link #getAction}.
      * </p>
      */
     public static final int ACTION_POINTER_DOWN     = 5;

     /**
      * Constant for {@link #getActionMasked}: A non-primary pointer has gone up.
      * <p>
      * Use {@link #getActionIndex} to retrieve the index of the pointer that changed.
      * </p><p>
      * The index is encoded in the {@link #ACTION_POINTER_INDEX_MASK} bits of the
      * unmasked action returned by {@link #getAction}.
      * </p>
      */
     public static final int ACTION_POINTER_UP       = 6;

     /**
      * Constant for {@link #getActionMasked}: A change happened but the pointer
      * is not down (unlike {@link #ACTION_MOVE}).  The motion contains the most
      * recent point, as well as any intermediate points since the last
      * hover move event.
      * <p>
      * This action is always delivered to the window or view under the pointer.
      * </p><p>
      * This action is not a touch event so it is delivered to
      * {@link View#onGenericMotionEvent(MotionEvent)} rather than
      * {@link View#onTouchEvent(MotionEvent)}.
      * </p>
      */
     public static final int ACTION_HOVER_MOVE       = 7;

     /**
      * Constant for {@link #getActionMasked}: The motion event contains relative
      * vertical and/or horizontal scroll offsets.  Use {@link #getAxisValue(int)}
      * to retrieve the information from {@link #AXIS_VSCROLL} and {@link #AXIS_HSCROLL}.
      * The pointer may or may not be down when this event is dispatched.
      * <p>
      * This action is always delivered to the window or view under the pointer, which
      * may not be the window or view currently touched.
      * </p><p>
      * This action is not a touch event so it is delivered to
      * {@link View#onGenericMotionEvent(MotionEvent)} rather than
      * {@link View#onTouchEvent(MotionEvent)}.
      * </p>
      */
     public static final int ACTION_SCROLL           = 8;

     /**
      * Constant for {@link #getActionMasked}: The pointer is not down but has entered the
      * boundaries of a window or view.
      * <p>
      * This action is always delivered to the window or view under the pointer.
      * </p><p>
      * This action is not a touch event so it is delivered to
      * {@link View#onGenericMotionEvent(MotionEvent)} rather than
      * {@link View#onTouchEvent(MotionEvent)}.
      * </p>
      */
     public static final int ACTION_HOVER_ENTER      = 9;

     /**
      * Constant for {@link #getActionMasked}: The pointer is not down but has exited the
      * boundaries of a window or view.
      * <p>
      * This action is always delivered to the window or view that was previously under the pointer.
      * </p><p>
      * This action is not a touch event so it is delivered to
      * {@link View#onGenericMotionEvent(MotionEvent)} rather than
      * {@link View#onTouchEvent(MotionEvent)}.
      * </p>
      */
     public static final int ACTION_HOVER_EXIT       = 10;

     /**
      * Constant for {@link #getActionMasked}: A button has been pressed.
      *
      * <p>
      * Use {@link #getActionButton()} to get which button was pressed.
      * </p><p>
      * This action is not a touch event so it is delivered to
      * {@link View#onGenericMotionEvent(MotionEvent)} rather than
      * {@link View#onTouchEvent(MotionEvent)}.
      * </p>
      */
     public static final int ACTION_BUTTON_PRESS   = 11;

     /**
      * Constant for {@link #getActionMasked}: A button has been released.
      *
      * <p>
      * Use {@link #getActionButton()} to get which button was released.
      * </p><p>
      * This action is not a touch event so it is delivered to
      * {@link View#onGenericMotionEvent(MotionEvent)} rather than
      * {@link View#onTouchEvent(MotionEvent)}.
      * </p>
      */
     public static final int ACTION_BUTTON_RELEASE  = 12;

     /**
      * Bits in the action code that represent a pointer index, used with
      * {@link #ACTION_POINTER_DOWN} and {@link #ACTION_POINTER_UP}.  Shifting
      * down by {@link #ACTION_POINTER_INDEX_SHIFT} provides the actual pointer
      * index where the data for the pointer going up or down can be found; you can
      * get its identifier with {@link #getPointerId(int)} and the actual
      * data with {@link #getX(int)} etc.
      *
      * @see #getActionIndex
      */
     public static final int ACTION_POINTER_INDEX_MASK  = 0xff00;

     /**
      * Bit shift for the action bits holding the pointer index as
      * defined by {@link #ACTION_POINTER_INDEX_MASK}.
      *
      * @see #getActionIndex
      */
     public static final int ACTION_POINTER_INDEX_SHIFT = 8;

     /**
      * @deprecated Use {@link #ACTION_POINTER_INDEX_MASK} to retrieve the
      * data index associated with {@link #ACTION_POINTER_DOWN}.
      */
     @Deprecated
     public static final int ACTION_POINTER_1_DOWN   = ACTION_POINTER_DOWN | 0x0000;

     /**
      * @deprecated Use {@link #ACTION_POINTER_INDEX_MASK} to retrieve the
      * data index associated with {@link #ACTION_POINTER_DOWN}.
      */
     @Deprecated
     public static final int ACTION_POINTER_2_DOWN   = ACTION_POINTER_DOWN | 0x0100;

     /**
      * @deprecated Use {@link #ACTION_POINTER_INDEX_MASK} to retrieve the
      * data index associated with {@link #ACTION_POINTER_DOWN}.
      */
     @Deprecated
     public static final int ACTION_POINTER_3_DOWN   = ACTION_POINTER_DOWN | 0x0200;

     /**
      * @deprecated Use {@link #ACTION_POINTER_INDEX_MASK} to retrieve the
      * data index associated with {@link #ACTION_POINTER_UP}.
      */
     @Deprecated
     public static final int ACTION_POINTER_1_UP     = ACTION_POINTER_UP | 0x0000;

     /**
      * @deprecated Use {@link #ACTION_POINTER_INDEX_MASK} to retrieve the
      * data index associated with {@link #ACTION_POINTER_UP}.
      */
     @Deprecated
     public static final int ACTION_POINTER_2_UP     = ACTION_POINTER_UP | 0x0100;

     /**
      * @deprecated Use {@link #ACTION_POINTER_INDEX_MASK} to retrieve the
      * data index associated with {@link #ACTION_POINTER_UP}.
      */
     @Deprecated
     public static final int ACTION_POINTER_3_UP     = ACTION_POINTER_UP | 0x0200;

     /**
      * @deprecated Renamed to {@link #ACTION_POINTER_INDEX_MASK} to match
      * the actual data contained in these bits.
      */
     @Deprecated
     public static final int ACTION_POINTER_ID_MASK  = 0xff00;

     /**
      * @deprecated Renamed to {@link #ACTION_POINTER_INDEX_SHIFT} to match
      * the actual data contained in these bits.
      */
     @Deprecated
     public static final int ACTION_POINTER_ID_SHIFT = 8;

     /**
      * This flag indicates that the window that received this motion event is partly
      * or wholly obscured by another visible window above it and the event directly passed through
      * the obscured area.
      *
      * A security sensitive application can check this flag to identify situations in which
      * a malicious application may have covered up part of its content for the purpose
      * of misleading the user or hijacking touches.  An appropriate response might be
      * to drop the suspect touches or to take additional precautions to confirm the user's
      * actual intent.
      */
     public static final int FLAG_WINDOW_IS_OBSCURED = MOTION_EVENT_FLAG_WINDOW_IS_OBSCURED;

     /**
      * This flag indicates that the window that received this motion event is partly
      * or wholly obscured by another visible window above it and the event did not directly pass
      * through the obscured area.
      *
      * A security sensitive application can check this flag to identify situations in which
      * a malicious application may have covered up part of its content for the purpose
      * of misleading the user or hijacking touches.  An appropriate response might be
      * to drop the suspect touches or to take additional precautions to confirm the user's
      * actual intent.
      *
      * Unlike FLAG_WINDOW_IS_OBSCURED, this is only true if the window that received this event is
      * obstructed in areas other than the touched location.
      */
     public static final int FLAG_WINDOW_IS_PARTIALLY_OBSCURED =
             MOTION_EVENT_FLAG_WINDOW_IS_PARTIALLY_OBSCURED;

     /**
      * This private flag is only set on {@link #ACTION_HOVER_MOVE} events and indicates that
      * this event will be immediately followed by a {@link #ACTION_HOVER_EXIT}. It is used to
      * prevent generating redundant {@link #ACTION_HOVER_ENTER} events.
      * @hide
      */
     public static final int FLAG_HOVER_EXIT_PENDING = MOTION_EVENT_FLAG_HOVER_EXIT_PENDING;

     /**
      * This flag indicates that the event has been generated by a gesture generator. It
      * provides a hint to the GestureDetector to not apply any touch slop.
      *
      * @hide
      */
     public static final int FLAG_IS_GENERATED_GESTURE = MOTION_EVENT_FLAG_IS_GENERATED_GESTURE;

     /**
      * This flag is only set for events with {@link #ACTION_POINTER_UP} and {@link #ACTION_CANCEL}.
      * It indicates that the pointer going up was an unintentional user touch. When FLAG_CANCELED
      * is set, the typical actions that occur in response for a pointer going up (such as click
      * handlers, end of drawing) should be aborted. This flag is typically set when the user was
      * accidentally touching the screen, such as by gripping the device, or placing the palm on the
      * screen.
      *
      * @see #ACTION_POINTER_UP
      * @see #ACTION_CANCEL
      */
     public static final int FLAG_CANCELED = INPUT_EVENT_FLAG_CANCELED;

     /**
      * This flag indicates that the event will not cause a focus change if it is directed to an
      * unfocused window, even if it an {@link #ACTION_DOWN}. This is typically used with pointer
      * gestures to allow the user to direct gestures to an unfocused window without bringing the
      * window into focus.
      * @hide
      */
     public static final int FLAG_NO_FOCUS_CHANGE = MOTION_EVENT_FLAG_NO_FOCUS_CHANGE;

     /**
      * This flag indicates that this event was modified by or generated from an accessibility
      * service. Value = 0x800
      * @hide
      */
     @TestApi
     public static final int FLAG_IS_ACCESSIBILITY_EVENT = INPUT_EVENT_FLAG_IS_ACCESSIBILITY_EVENT;

     /**
      * Private flag that indicates when the system has detected that this motion event
      * may be inconsistent with respect to the sequence of previously delivered motion events,
      * such as when a pointer move event is sent but the pointer is not down.
      *
      * @hide
      * @see #isTainted
      * @see #setTainted
      */
     public static final int FLAG_TAINTED = INPUT_EVENT_FLAG_TAINTED;

     /**
      * Private flag indicating that this event was synthesized by the system and should be delivered
      * to the accessibility focused view first. When being dispatched such an event is not handled
      * by predecessors of the accessibility focused view and after the event reaches that view the
      * flag is cleared and normal event dispatch is performed. This ensures that the platform can
      * click on any view that has accessibility focus which is semantically equivalent to asking the
      * view to perform a click accessibility action but more generic as views not implementing click
      * action correctly can still be activated.
      *
      * @hide
      * @see #isTargetAccessibilityFocus()
      * @see #setTargetAccessibilityFocus(boolean)
      */
     public static final int FLAG_TARGET_ACCESSIBILITY_FOCUS =
             MOTION_EVENT_FLAG_TARGET_ACCESSIBILITY_FOCUS;

     /**
      * Flag indicating the motion event intersected the top edge of the screen.
      */
     public static final int EDGE_TOP = 0x00000001;

     /**
      * Flag indicating the motion event intersected the bottom edge of the screen.
      */
     public static final int EDGE_BOTTOM = 0x00000002;

     /**
      * Flag indicating the motion event intersected the left edge of the screen.
      */
     public static final int EDGE_LEFT = 0x00000004;

     /**
      * Flag indicating the motion event intersected the right edge of the screen.
      */
     public static final int EDGE_RIGHT = 0x00000008;

     /**
      * Axis constant: X axis of a motion event.
      * <p>
      * <ul>
      * <li>For a touch screen, reports the absolute X screen position of the center of
      * the touch contact area.  The units are display pixels.
      * <li>For a touch pad, reports the absolute X surface position of the center of the touch
      * contact area.  The units are device-dependent; use {@link InputDevice#getMotionRange(int)}
      * to query the effective range of values.
      * <li>For a mouse, reports the absolute X screen position of the mouse pointer.
      * The units are display pixels.
      * <li>For a trackball, reports the relative horizontal displacement of the trackball.
      * The value is normalized to a range from -1.0 (left) to 1.0 (right).
      * <li>For a joystick, reports the absolute X position of the joystick.
      * The value is normalized to a range from -1.0 (left) to 1.0 (right).
      * </ul>
      * </p>
      *
      * @see #getX(int)
      * @see #getHistoricalX(int, int)
      * @see MotionEvent.PointerCoords#x
      * @see InputDevice#getMotionRange
      */
     public static final int AXIS_X = 0;

     /**
      * Axis constant: Y axis of a motion event.
      * <p>
      * <ul>
      * <li>For a touch screen, reports the absolute Y screen position of the center of
      * the touch contact area.  The units are display pixels.
      * <li>For a touch pad, reports the absolute Y surface position of the center of the touch
      * contact area.  The units are device-dependent; use {@link InputDevice#getMotionRange(int)}
      * to query the effective range of values.
      * <li>For a mouse, reports the absolute Y screen position of the mouse pointer.
      * The units are display pixels.
      * <li>For a trackball, reports the relative vertical displacement of the trackball.
      * The value is normalized to a range from -1.0 (up) to 1.0 (down).
      * <li>For a joystick, reports the absolute Y position of the joystick.
      * The value is normalized to a range from -1.0 (up or far) to 1.0 (down or near).
      * </ul>
      * </p>
      *
      * @see #getY(int)
      * @see #getHistoricalY(int, int)
      * @see MotionEvent.PointerCoords#y
      * @see InputDevice#getMotionRange
      */
     public static final int AXIS_Y = 1;

     /**
      * Axis constant: Pressure axis of a motion event.
      * <p>
      * <ul>
      * <li>For a touch screen or touch pad, reports the approximate pressure applied to the surface
      * by a finger or other tool.  The value is normalized to a range 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.
      * <li>For a trackball, the value is set to 1 if the trackball button is pressed
      * or 0 otherwise.
      * <li>For a mouse, the value is set to 1 if the primary mouse button is pressed
      * or 0 otherwise.
      * </ul>
      * </p>
      *
      * @see #getPressure(int)
      * @see #getHistoricalPressure(int, int)
      * @see MotionEvent.PointerCoords#pressure
      * @see InputDevice#getMotionRange
      */
     public static final int AXIS_PRESSURE = 2;

     /**
      * Axis constant: Size axis of a motion event.
      * <p>
      * <ul>
      * <li>For a touch screen or touch pad, reports the approximate size of the contact area in
      * relation to the maximum detectable size for the device.  The value is normalized
      * to a range from 0 (smallest detectable size) to 1 (largest detectable size),
      * although it is not a linear scale.  This value is of limited use.
      * To obtain calibrated size information, use
      * {@link #AXIS_TOUCH_MAJOR} or {@link #AXIS_TOOL_MAJOR}.
      * </ul>
      * </p>
      *
      * @see #getSize(int)
      * @see #getHistoricalSize(int, int)
      * @see MotionEvent.PointerCoords#size
      * @see InputDevice#getMotionRange
      */
     public static final int AXIS_SIZE = 3;

     /**
      * Axis constant: TouchMajor axis of a motion event.
      * <p>
      * <ul>
      * <li>For a touch screen, reports the length of the major axis of an ellipse that
      * represents the touch area at the point of contact.
      * The units are display pixels.
      * <li>For a touch pad, reports the length of the major axis of an ellipse that
      * represents the touch area at the point of contact.
      * The units are device-dependent; use {@link InputDevice#getMotionRange(int)}
      * to query the effective range of values.
      * </ul>
      * </p>
      *
      * @see #getTouchMajor(int)
      * @see #getHistoricalTouchMajor(int, int)
      * @see MotionEvent.PointerCoords#touchMajor
      * @see InputDevice#getMotionRange
      */
     public static final int AXIS_TOUCH_MAJOR = 4;

     /**
      * Axis constant: TouchMinor axis of a motion event.
      * <p>
      * <ul>
      * <li>For a touch screen, reports the length of the minor axis of an ellipse that
      * represents the touch area at the point of contact.
      * The units are display pixels.
      * <li>For a touch pad, reports the length of the minor axis of an ellipse that
      * represents the touch area at the point of contact.
      * The units are device-dependent; use {@link InputDevice#getMotionRange(int)}
      * to query the effective range of values.
      * </ul>
      * </p><p>
      * When the touch is circular, the major and minor axis lengths will be equal to one another.
      * </p>
      *
      * @see #getTouchMinor(int)
      * @see #getHistoricalTouchMinor(int, int)
      * @see MotionEvent.PointerCoords#touchMinor
      * @see InputDevice#getMotionRange
      */
     public static final int AXIS_TOUCH_MINOR = 5;

     /**
      * Axis constant: ToolMajor axis of a motion event.
      * <p>
      * <ul>
      * <li>For a touch screen, reports the length of the major axis of an ellipse that
      * represents the size of the approaching finger or tool used to make contact.
      * <li>For a touch pad, reports the length of the major axis of an ellipse that
      * represents the size of the approaching finger or tool used to make contact.
      * The units are device-dependent; use {@link InputDevice#getMotionRange(int)}
      * to query the effective range of values.
      * </ul>
      * </p><p>
      * When the touch is circular, the major and minor axis lengths will be equal to one another.
      * </p><p>
      * The tool size may be larger than the touch size since the tool may not be fully
      * in contact with the touch sensor.
      * </p>
      *
      * @see #getToolMajor(int)
      * @see #getHistoricalToolMajor(int, int)
      * @see MotionEvent.PointerCoords#toolMajor
      * @see InputDevice#getMotionRange
      */
     public static final int AXIS_TOOL_MAJOR = 6;

     /**
      * Axis constant: ToolMinor axis of a motion event.
      * <p>
      * <ul>
      * <li>For a touch screen, reports the length of the minor axis of an ellipse that
      * represents the size of the approaching finger or tool used to make contact.
      * <li>For a touch pad, reports the length of the minor axis of an ellipse that
      * represents the size of the approaching finger or tool used to make contact.
      * The units are device-dependent; use {@link InputDevice#getMotionRange(int)}
      * to query the effective range of values.
      * </ul>
      * </p><p>
      * When the touch is circular, the major and minor axis lengths will be equal to one another.
      * </p><p>
      * The tool size may be larger than the touch size since the tool may not be fully
      * in contact with the touch sensor.
      * </p>
      *
      * @see #getToolMinor(int)
      * @see #getHistoricalToolMinor(int, int)
      * @see MotionEvent.PointerCoords#toolMinor
      * @see InputDevice#getMotionRange
      */
     public static final int AXIS_TOOL_MINOR = 7;

     /**
      * Axis constant: Orientation axis of a motion event.
      * <p>
      * <ul>
      * <li>For a touch screen or touch pad, reports the orientation of the finger
      * or tool in radians relative to the vertical plane of the device.
      * An angle of 0 radians 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).
      * <li>For a stylus, the orientation indicates the direction in which the stylus
      * is pointing in relation to the vertical axis of the current orientation of the screen.
      * The range is from -PI radians to PI radians, where 0 is pointing up,
      * -PI/2 radians is pointing left, -PI or PI radians is pointing down, and PI/2 radians
      * is pointing right.  See also {@link #AXIS_TILT}.
      * </ul>
      * </p>
      *
      * @see #getOrientation(int)
      * @see #getHistoricalOrientation(int, int)
      * @see MotionEvent.PointerCoords#orientation
      * @see InputDevice#getMotionRange
      */
     public static final int AXIS_ORIENTATION = 8;

     /**
      * Axis constant: Vertical Scroll axis of a motion event.
      * <p>
      * <ul>
      * <li>For a mouse, reports the relative movement of the vertical scroll wheel.
      * The value is normalized to a range from -1.0 (down) to 1.0 (up).
      * </ul>
      * </p><p>
      * This axis should be used to scroll views vertically.
      * </p>
      *
      * @see #getAxisValue(int, int)
      * @see #getHistoricalAxisValue(int, int, int)
      * @see MotionEvent.PointerCoords#getAxisValue(int)
      * @see InputDevice#getMotionRange
      */
     public static final int AXIS_VSCROLL = 9;

     /**
      * Axis constant: Horizontal Scroll axis of a motion event.
      * <p>
      * <ul>
      * <li>For a mouse, reports the relative movement of the horizontal scroll wheel.
      * The value is normalized to a range from -1.0 (left) to 1.0 (right).
      * </ul>
      * </p><p>
      * This axis should be used to scroll views horizontally.
      * </p>
      *
      * @see #getAxisValue(int, int)
      * @see #getHistoricalAxisValue(int, int, int)
      * @see MotionEvent.PointerCoords#getAxisValue(int)
      * @see InputDevice#getMotionRange
      */
     public static final int AXIS_HSCROLL = 10;

     /**
      * Axis constant: Z axis of a motion event.
      * <p>
      * <ul>
      * <li>For a joystick, reports the absolute Z position of the joystick.
      * The value is normalized to a range from -1.0 (high) to 1.0 (low).
      * <em>On game pads with two analog joysticks, this axis is often reinterpreted
      * to report the absolute X position of the second joystick instead.</em>
      * </ul>
      * </p>
      *
      * @see #getAxisValue(int, int)
      * @see #getHistoricalAxisValue(int, int, int)
      * @see MotionEvent.PointerCoords#getAxisValue(int)
      * @see InputDevice#getMotionRange
      */
     public static final int AXIS_Z = 11;

     /**
      * Axis constant: X Rotation axis of a motion event.
      * <p>
      * <ul>
      * <li>For a joystick, reports the absolute rotation angle about the X axis.
      * The value is normalized to a range from -1.0 (counter-clockwise) to 1.0 (clockwise).
      * </ul>
      * </p>
      *
      * @see #getAxisValue(int, int)
      * @see #getHistoricalAxisValue(int, int, int)
      * @see MotionEvent.PointerCoords#getAxisValue(int)
      * @see InputDevice#getMotionRange
      */
     public static final int AXIS_RX = 12;

     /**
      * Axis constant: Y Rotation axis of a motion event.
      * <p>
      * <ul>
      * <li>For a joystick, reports the absolute rotation angle about the Y axis.
      * The value is normalized to a range from -1.0 (counter-clockwise) to 1.0 (clockwise).
      * </ul>
      * </p>
      *
      * @see #getAxisValue(int, int)
      * @see #getHistoricalAxisValue(int, int, int)
      * @see MotionEvent.PointerCoords#getAxisValue(int)
      * @see InputDevice#getMotionRange
      */
     public static final int AXIS_RY = 13;

     /**
      * Axis constant: Z Rotation axis of a motion event.
      * <p>
      * <ul>
      * <li>For a joystick, reports the absolute rotation angle about the Z axis.
      * The value is normalized to a range from -1.0 (counter-clockwise) to 1.0 (clockwise).
      * <em>On game pads with two analog joysticks, this axis is often reinterpreted
      * to report the absolute Y position of the second joystick instead.</em>
      * </ul>
      * </p>
      *
      * @see #getAxisValue(int, int)
      * @see #getHistoricalAxisValue(int, int, int)
      * @see MotionEvent.PointerCoords#getAxisValue(int)
      * @see InputDevice#getMotionRange
      */
     public static final int AXIS_RZ = 14;

     /**
      * Axis constant: Hat X axis of a motion event.
      * <p>
      * <ul>
      * <li>For a joystick, reports the absolute X position of the directional hat control.
      * The value is normalized to a range from -1.0 (left) to 1.0 (right).
      * </ul>
      * </p>
      *
      * @see #getAxisValue(int, int)
      * @see #getHistoricalAxisValue(int, int, int)
      * @see MotionEvent.PointerCoords#getAxisValue(int)
      * @see InputDevice#getMotionRange
      */
     public static final int AXIS_HAT_X = 15;

     /**
      * Axis constant: Hat Y axis of a motion event.
      * <p>
      * <ul>
      * <li>For a joystick, reports the absolute Y position of the directional hat control.
      * The value is normalized to a range from -1.0 (up) to 1.0 (down).
      * </ul>
      * </p>
      *
      * @see #getAxisValue(int, int)
      * @see #getHistoricalAxisValue(int, int, int)
      * @see MotionEvent.PointerCoords#getAxisValue(int)
      * @see InputDevice#getMotionRange
      */
     public static final int AXIS_HAT_Y = 16;

     /**
      * Axis constant: Left Trigger axis of a motion event.
      * <p>
      * <ul>
      * <li>For a joystick, reports the absolute position of the left trigger control.
      * The value is normalized to a range from 0.0 (released) to 1.0 (fully pressed).
      * </ul>
      * </p>
      *
      * @see #getAxisValue(int, int)
      * @see #getHistoricalAxisValue(int, int, int)
      * @see MotionEvent.PointerCoords#getAxisValue(int)
      * @see InputDevice#getMotionRange
      */
     public static final int AXIS_LTRIGGER = 17;

     /**
      * Axis constant: Right Trigger axis of a motion event.
      * <p>
      * <ul>
      * <li>For a joystick, reports the absolute position of the right trigger control.
      * The value is normalized to a range from 0.0 (released) to 1.0 (fully pressed).
      * </ul>
      * </p>
      *
      * @see #getAxisValue(int, int)
      * @see #getHistoricalAxisValue(int, int, int)
      * @see MotionEvent.PointerCoords#getAxisValue(int)
      * @see InputDevice#getMotionRange
      */
     public static final int AXIS_RTRIGGER = 18;

     /**
      * Axis constant: Throttle axis of a motion event.
      * <p>
      * <ul>
      * <li>For a joystick, reports the absolute position of the throttle control.
      * The value is normalized to a range from 0.0 (fully open) to 1.0 (fully closed).
      * </ul>
      * </p>
      *
      * @see #getAxisValue(int, int)
      * @see #getHistoricalAxisValue(int, int, int)
      * @see MotionEvent.PointerCoords#getAxisValue(int)
      * @see InputDevice#getMotionRange
      */
     public static final int AXIS_THROTTLE = 19;

     /**
      * Axis constant: Rudder axis of a motion event.
      * <p>
      * <ul>
      * <li>For a joystick, reports the absolute position of the rudder control.
      * The value is normalized to a range from -1.0 (turn left) to 1.0 (turn right).
      * </ul>
      * </p>
      *
      * @see #getAxisValue(int, int)
      * @see #getHistoricalAxisValue(int, int, int)
      * @see MotionEvent.PointerCoords#getAxisValue(int)
      * @see InputDevice#getMotionRange
      */
     public static final int AXIS_RUDDER = 20;

     /**
      * Axis constant: Wheel axis of a motion event.
      * <p>
      * <ul>
      * <li>For a joystick, reports the absolute position of the steering wheel control.
      * The value is normalized to a range from -1.0 (turn left) to 1.0 (turn right).
      * </ul>
      * </p>
      *
      * @see #getAxisValue(int, int)
      * @see #getHistoricalAxisValue(int, int, int)
      * @see MotionEvent.PointerCoords#getAxisValue(int)
      * @see InputDevice#getMotionRange
      */
     public static final int AXIS_WHEEL = 21;

     /**
      * Axis constant: Gas axis of a motion event.
      * <p>
      * <ul>
      * <li>For a joystick, reports the absolute position of the gas (accelerator) control.
      * The value is normalized to a range from 0.0 (no acceleration)
      * to 1.0 (maximum acceleration).
      * </ul>
      * </p>
      *
      * @see #getAxisValue(int, int)
      * @see #getHistoricalAxisValue(int, int, int)
      * @see MotionEvent.PointerCoords#getAxisValue(int)
      * @see InputDevice#getMotionRange
      */
     public static final int AXIS_GAS = 22;

     /**
      * Axis constant: Brake axis of a motion event.
      * <p>
      * <ul>
      * <li>For a joystick, reports the absolute position of the brake control.
      * The value is normalized to a range from 0.0 (no braking) to 1.0 (maximum braking).
      * </ul>
      * </p>
      *
      * @see #getAxisValue(int, int)
      * @see #getHistoricalAxisValue(int, int, int)
      * @see MotionEvent.PointerCoords#getAxisValue(int)
      * @see InputDevice#getMotionRange
      */
     public static final int AXIS_BRAKE = 23;

     /**
      * Axis constant: Distance axis of a motion event.
      * <p>
      * <ul>
      * <li>For a stylus, reports the distance of the stylus from the screen.
      * A value of 0.0 indicates direct contact and larger values indicate increasing
      * distance from the surface.
      * </ul>
      * </p>
      *
      * @see #getAxisValue(int, int)
      * @see #getHistoricalAxisValue(int, int, int)
      * @see MotionEvent.PointerCoords#getAxisValue(int)
      * @see InputDevice#getMotionRange
      */
     public static final int AXIS_DISTANCE = 24;

     /**
      * Axis constant: Tilt axis of a motion event.
      * <p>
      * <ul>
      * <li>For a stylus, reports the tilt angle of the stylus in radians where
      * 0 radians indicates that the stylus is being held perpendicular to the
      * surface, and PI/2 radians indicates that the stylus is being held flat
      * against the surface.
      * </ul>
      * </p>
      *
      * @see #getAxisValue(int, int)
      * @see #getHistoricalAxisValue(int, int, int)
      * @see MotionEvent.PointerCoords#getAxisValue(int, int)
      * @see InputDevice#getMotionRange
      */
     public static final int AXIS_TILT = 25;

     /**
      * Axis constant: Generic scroll axis of a motion event.
      * <p>
      * <ul>
      * <li>Reports the relative movement of the generic scrolling device.
      * </ul>
      * </p><p>
      * This axis should be used for scroll events that are neither strictly vertical nor horizontal.
      * A good example would be the rotation of a rotary encoder input device.
      * </p>
      *
      * @see #getAxisValue(int, int)
      */
     public static final int AXIS_SCROLL = 26;

     /**
      * Axis constant: The movement of x position of a motion event.
      * <p>
      * <ul>
      * <li>For a mouse, reports a difference of x position between the previous position.
      * This is useful when pointer is captured, in that case the mouse pointer doesn't change
      * the location but this axis reports the difference which allows the app to see
      * how the mouse is moved.
      * </ul>
      * </p>
      *
      * @see #getAxisValue(int, int)
      * @see #getHistoricalAxisValue(int, int, int)
      * @see MotionEvent.PointerCoords#getAxisValue(int, int)
      * @see InputDevice#getMotionRange
      */
     public static final int AXIS_RELATIVE_X = 27;

     /**
      * Axis constant: The movement of y position of a motion event.
      * <p>
      * This is similar to {@link #AXIS_RELATIVE_X} but for y-axis.
      * </p>
      *
      * @see #getAxisValue(int, int)
      * @see #getHistoricalAxisValue(int, int, int)
      * @see MotionEvent.PointerCoords#getAxisValue(int, int)
      * @see InputDevice#getMotionRange
      */
     public static final int AXIS_RELATIVE_Y = 28;

     /**
      * Axis constant: Generic 1 axis of a motion event.
      * The interpretation of a generic axis is device-specific.
      *
      * @see #getAxisValue(int, int)
      * @see #getHistoricalAxisValue(int, int, int)
      * @see MotionEvent.PointerCoords#getAxisValue(int)
      * @see InputDevice#getMotionRange
      */
     public static final int AXIS_GENERIC_1 = 32;

     /**
      * Axis constant: Generic 2 axis of a motion event.
      * The interpretation of a generic axis is device-specific.
      *
      * @see #getAxisValue(int, int)
      * @see #getHistoricalAxisValue(int, int, int)
      * @see MotionEvent.PointerCoords#getAxisValue(int)
      * @see InputDevice#getMotionRange
      */
     public static final int AXIS_GENERIC_2 = 33;

     /**
      * Axis constant: Generic 3 axis of a motion event.
      * The interpretation of a generic axis is device-specific.
      *
      * @see #getAxisValue(int, int)
      * @see #getHistoricalAxisValue(int, int, int)
      * @see MotionEvent.PointerCoords#getAxisValue(int)
      * @see InputDevice#getMotionRange
      */
     public static final int AXIS_GENERIC_3 = 34;

     /**
      * Axis constant: Generic 4 axis of a motion event.
      * The interpretation of a generic axis is device-specific.
      *
      * @see #getAxisValue(int, int)
      * @see #getHistoricalAxisValue(int, int, int)
      * @see MotionEvent.PointerCoords#getAxisValue(int)
      * @see InputDevice#getMotionRange
      */
     public static final int AXIS_GENERIC_4 = 35;

     /**
      * Axis constant: Generic 5 axis of a motion event.
      * The interpretation of a generic axis is device-specific.
      *
      * @see #getAxisValue(int, int)
      * @see #getHistoricalAxisValue(int, int, int)
      * @see MotionEvent.PointerCoords#getAxisValue(int)
      * @see InputDevice#getMotionRange
      */
     public static final int AXIS_GENERIC_5 = 36;

     /**
      * Axis constant: Generic 6 axis of a motion event.
      * The interpretation of a generic axis is device-specific.
      *
      * @see #getAxisValue(int, int)
      * @see #getHistoricalAxisValue(int, int, int)
      * @see MotionEvent.PointerCoords#getAxisValue(int)
      * @see InputDevice#getMotionRange
      */
     public static final int AXIS_GENERIC_6 = 37;

     /**
      * Axis constant: Generic 7 axis of a motion event.
      * The interpretation of a generic axis is device-specific.
      *
      * @see #getAxisValue(int, int)
      * @see #getHistoricalAxisValue(int, int, int)
      * @see MotionEvent.PointerCoords#getAxisValue(int)
      * @see InputDevice#getMotionRange
      */
     public static final int AXIS_GENERIC_7 = 38;

     /**
      * Axis constant: Generic 8 axis of a motion event.
      * The interpretation of a generic axis is device-specific.
      *
      * @see #getAxisValue(int, int)
      * @see #getHistoricalAxisValue(int, int, int)
      * @see MotionEvent.PointerCoords#getAxisValue(int)
      * @see InputDevice#getMotionRange
      */
     public static final int AXIS_GENERIC_8 = 39;

     /**
      * Axis constant: Generic 9 axis of a motion event.
      * The interpretation of a generic axis is device-specific.
      *
      * @see #getAxisValue(int, int)
      * @see #getHistoricalAxisValue(int, int, int)
      * @see MotionEvent.PointerCoords#getAxisValue(int)
      * @see InputDevice#getMotionRange
      */
     public static final int AXIS_GENERIC_9 = 40;

     /**
      * Axis constant: Generic 10 axis of a motion event.
      * The interpretation of a generic axis is device-specific.
      *
      * @see #getAxisValue(int, int)
      * @see #getHistoricalAxisValue(int, int, int)
      * @see MotionEvent.PointerCoords#getAxisValue(int)
      * @see InputDevice#getMotionRange
      */
     public static final int AXIS_GENERIC_10 = 41;

     /**
      * Axis constant: Generic 11 axis of a motion event.
      * The interpretation of a generic axis is device-specific.
      *
      * @see #getAxisValue(int, int)
      * @see #getHistoricalAxisValue(int, int, int)
      * @see MotionEvent.PointerCoords#getAxisValue(int)
      * @see InputDevice#getMotionRange
      */
     public static final int AXIS_GENERIC_11 = 42;

     /**
      * Axis constant: Generic 12 axis of a motion event.
      * The interpretation of a generic axis is device-specific.
      *
      * @see #getAxisValue(int, int)
      * @see #getHistoricalAxisValue(int, int, int)
      * @see MotionEvent.PointerCoords#getAxisValue(int)
      * @see InputDevice#getMotionRange
      */
     public static final int AXIS_GENERIC_12 = 43;

     /**
      * Axis constant: Generic 13 axis of a motion event.
      * The interpretation of a generic axis is device-specific.
      *
      * @see #getAxisValue(int, int)
      * @see #getHistoricalAxisValue(int, int, int)
      * @see MotionEvent.PointerCoords#getAxisValue(int)
      * @see InputDevice#getMotionRange
      */
     public static final int AXIS_GENERIC_13 = 44;

     /**
      * Axis constant: Generic 14 axis of a motion event.
      * The interpretation of a generic axis is device-specific.
      *
      * @see #getAxisValue(int, int)
      * @see #getHistoricalAxisValue(int, int, int)
      * @see MotionEvent.PointerCoords#getAxisValue(int)
      * @see InputDevice#getMotionRange
      */
     public static final int AXIS_GENERIC_14 = 45;

     /**
      * Axis constant: Generic 15 axis of a motion event.
      * The interpretation of a generic axis is device-specific.
      *
      * @see #getAxisValue(int, int)
      * @see #getHistoricalAxisValue(int, int, int)
      * @see MotionEvent.PointerCoords#getAxisValue(int)
      * @see InputDevice#getMotionRange
      */
     public static final int AXIS_GENERIC_15 = 46;

     /**
      * Axis constant: Generic 16 axis of a motion event.
      * The interpretation of a generic axis is device-specific.
      *
      * @see #getAxisValue(int, int)
      * @see #getHistoricalAxisValue(int, int, int)
      * @see MotionEvent.PointerCoords#getAxisValue(int)
      * @see InputDevice#getMotionRange
      */
     public static final int AXIS_GENERIC_16 = 47;

     /**
      * Axis constant: X gesture offset axis of a motion event.
      * <p>
      * <ul>
      * <li>For a touch pad, reports the distance that a swipe gesture has moved in the X axis, as a
      * proportion of the touch pad's size. For example, if a touch pad is 1000 units wide, and a
      * swipe gesture starts at X = 500 then moves to X = 400, this axis would have a value of
      * -0.1.
      * </ul>
      * These values are relative to the state from the last event, not accumulated, so developers
      * should make sure to process this axis value for all batched historical events.
      * <p>
      * This axis is only set on the first pointer in a motion event.
      */
     public static final int AXIS_GESTURE_X_OFFSET = 48;

     /**
      * Axis constant: Y gesture offset axis of a motion event.
      *
      * The same as {@link #AXIS_GESTURE_X_OFFSET}, but for the Y axis.
      */
     public static final int AXIS_GESTURE_Y_OFFSET = 49;

     /**
      * Axis constant: X scroll distance axis of a motion event.
      * <p>
      * <ul>
      * <li>For a touch pad, reports the distance that should be scrolled in the X axis as a result
      * of the user's two-finger scroll gesture, in display pixels.
      * </ul>
      * These values are relative to the state from the last event, not accumulated, so developers
      * should make sure to process this axis value for all batched historical events.
      * <p>
      * This axis is only set on the first pointer in a motion event.
      */
     public static final int AXIS_GESTURE_SCROLL_X_DISTANCE = 50;

     /**
      * Axis constant: Y scroll distance axis of a motion event.
      *
      * The same as {@link #AXIS_GESTURE_SCROLL_X_DISTANCE}, but for the Y axis.
      */
     public static final int AXIS_GESTURE_SCROLL_Y_DISTANCE = 51;

     /**
      * Axis constant: pinch scale factor of a motion event.
      * <p>
      * <ul>
      * <li>For a touch pad, reports the change in distance between the fingers when the user is
      * making a pinch gesture, as a proportion of the previous distance. For example, if the fingers
      * were 50 units apart and are now 52 units apart, the scale factor would be 1.04.
      * </ul>
      * These values are relative to the state from the last event, not accumulated, so developers
      * should make sure to process this axis value for all batched historical events.
      * <p>
      * This axis is only set on the first pointer in a motion event.
      */
     public static final int AXIS_GESTURE_PINCH_SCALE_FACTOR = 52;

     /**
      * Axis constant: the number of fingers being used in a multi-finger swipe gesture.
      * <p>
      * <ul>
      * <li>For a touch pad, reports the number of fingers being used in a multi-finger swipe gesture
      * (with CLASSIFICATION_MULTI_FINGER_SWIPE).
      * </ul>
      * <p>
      * Since CLASSIFICATION_MULTI_FINGER_SWIPE is a hidden API, so is this axis. It is only set on
      * the first pointer in a motion event.
      * @hide
      */
     public static final int AXIS_GESTURE_SWIPE_FINGER_COUNT = 53;

     // NOTE: If you add a new axis here you must also add it to:
     //  frameworks/native/include/android/input.h
     //  frameworks/native/libs/input/InputEventLabels.cpp
     //  cts/tests/tests/view/src/android/view/cts/MotionEventTest.java (testAxisFromToString)

     // Symbolic names of all axes.
     private static final SparseArray<String> AXIS_SYMBOLIC_NAMES = new SparseArray<String>();
     static {
         SparseArray<String> names = AXIS_SYMBOLIC_NAMES;
         names.append(AXIS_X, "AXIS_X");
         names.append(AXIS_Y, "AXIS_Y");
         names.append(AXIS_PRESSURE, "AXIS_PRESSURE");
         names.append(AXIS_SIZE, "AXIS_SIZE");
         names.append(AXIS_TOUCH_MAJOR, "AXIS_TOUCH_MAJOR");
         names.append(AXIS_TOUCH_MINOR, "AXIS_TOUCH_MINOR");
         names.append(AXIS_TOOL_MAJOR, "AXIS_TOOL_MAJOR");
         names.append(AXIS_TOOL_MINOR, "AXIS_TOOL_MINOR");
         names.append(AXIS_ORIENTATION, "AXIS_ORIENTATION");
         names.append(AXIS_VSCROLL, "AXIS_VSCROLL");
         names.append(AXIS_HSCROLL, "AXIS_HSCROLL");
         names.append(AXIS_Z, "AXIS_Z");
         names.append(AXIS_RX, "AXIS_RX");
         names.append(AXIS_RY, "AXIS_RY");
         names.append(AXIS_RZ, "AXIS_RZ");
         names.append(AXIS_HAT_X, "AXIS_HAT_X");
         names.append(AXIS_HAT_Y, "AXIS_HAT_Y");
         names.append(AXIS_LTRIGGER, "AXIS_LTRIGGER");
         names.append(AXIS_RTRIGGER, "AXIS_RTRIGGER");
         names.append(AXIS_THROTTLE, "AXIS_THROTTLE");
         names.append(AXIS_RUDDER, "AXIS_RUDDER");
         names.append(AXIS_WHEEL, "AXIS_WHEEL");
         names.append(AXIS_GAS, "AXIS_GAS");
         names.append(AXIS_BRAKE, "AXIS_BRAKE");
         names.append(AXIS_DISTANCE, "AXIS_DISTANCE");
         names.append(AXIS_TILT, "AXIS_TILT");
         names.append(AXIS_SCROLL, "AXIS_SCROLL");
         names.append(AXIS_RELATIVE_X, "AXIS_REALTIVE_X");
         names.append(AXIS_RELATIVE_Y, "AXIS_REALTIVE_Y");
         names.append(AXIS_GENERIC_1, "AXIS_GENERIC_1");
         names.append(AXIS_GENERIC_2, "AXIS_GENERIC_2");
         names.append(AXIS_GENERIC_3, "AXIS_GENERIC_3");
         names.append(AXIS_GENERIC_4, "AXIS_GENERIC_4");
         names.append(AXIS_GENERIC_5, "AXIS_GENERIC_5");
         names.append(AXIS_GENERIC_6, "AXIS_GENERIC_6");
         names.append(AXIS_GENERIC_7, "AXIS_GENERIC_7");
         names.append(AXIS_GENERIC_8, "AXIS_GENERIC_8");
         names.append(AXIS_GENERIC_9, "AXIS_GENERIC_9");
         names.append(AXIS_GENERIC_10, "AXIS_GENERIC_10");
         names.append(AXIS_GENERIC_11, "AXIS_GENERIC_11");
         names.append(AXIS_GENERIC_12, "AXIS_GENERIC_12");
         names.append(AXIS_GENERIC_13, "AXIS_GENERIC_13");
         names.append(AXIS_GENERIC_14, "AXIS_GENERIC_14");
         names.append(AXIS_GENERIC_15, "AXIS_GENERIC_15");
         names.append(AXIS_GENERIC_16, "AXIS_GENERIC_16");
         names.append(AXIS_GESTURE_X_OFFSET, "AXIS_GESTURE_X_OFFSET");
         names.append(AXIS_GESTURE_Y_OFFSET, "AXIS_GESTURE_Y_OFFSET");
         names.append(AXIS_GESTURE_SCROLL_X_DISTANCE, "AXIS_GESTURE_SCROLL_X_DISTANCE");
         names.append(AXIS_GESTURE_SCROLL_Y_DISTANCE, "AXIS_GESTURE_SCROLL_Y_DISTANCE");
         names.append(AXIS_GESTURE_PINCH_SCALE_FACTOR, "AXIS_GESTURE_PINCH_SCALE_FACTOR");
         names.append(AXIS_GESTURE_SWIPE_FINGER_COUNT, "AXIS_GESTURE_SWIPE_FINGER_COUNT");
     }

     /**
      * Button constant: Primary button (left mouse button).
      *
      * This button constant is not set in response to simple touches with a finger
      * or stylus tip.  The user must actually push a button.
      *
      * @see #getButtonState
      */
     public static final int BUTTON_PRIMARY = 1 << 0;

     /**
      * Button constant: Secondary button (right mouse button).
      *
      * @see #getButtonState
      */
     public static final int BUTTON_SECONDARY = 1 << 1;

     /**
      * Button constant: Tertiary button (middle mouse button).
      *
      * @see #getButtonState
      */
     public static final int BUTTON_TERTIARY = 1 << 2;

     /**
      * Button constant: Back button pressed (mouse back button).
      * <p>
      * The system may send a {@link KeyEvent#KEYCODE_BACK} key press to the application
      * when this button is pressed.
      * </p>
      *
      * @see #getButtonState
      */
     public static final int BUTTON_BACK = 1 << 3;

     /**
      * Button constant: Forward button pressed (mouse forward button).
      * <p>
      * The system may send a {@link KeyEvent#KEYCODE_FORWARD} key press to the application
      * when this button is pressed.
      * </p>
      *
      * @see #getButtonState
      */
     public static final int BUTTON_FORWARD = 1 << 4;

     /**
      * Button constant: Primary stylus button pressed.
      *
      * @see #getButtonState
      */
     public static final int BUTTON_STYLUS_PRIMARY = 1 << 5;

     /**
      * Button constant: Secondary stylus button pressed.
      *
      * @see #getButtonState
      */
     public static final int BUTTON_STYLUS_SECONDARY = 1 << 6;

     // NOTE: If you add a new axis here you must also add it to:
     //  native/include/android/input.h

     // Symbolic names of all button states in bit order from least significant
     // to most significant.
     private static final String[] BUTTON_SYMBOLIC_NAMES = new String[] {
         "BUTTON_PRIMARY",
         "BUTTON_SECONDARY",
         "BUTTON_TERTIARY",
         "BUTTON_BACK",
         "BUTTON_FORWARD",
         "BUTTON_STYLUS_PRIMARY",
         "BUTTON_STYLUS_SECONDARY",
         "0x00000080",
         "0x00000100",
         "0x00000200",
         "0x00000400",
         "0x00000800",
         "0x00001000",
         "0x00002000",
         "0x00004000",
         "0x00008000",
         "0x00010000",
         "0x00020000",
         "0x00040000",
         "0x00080000",
         "0x00100000",
         "0x00200000",
         "0x00400000",
         "0x00800000",
         "0x01000000",
         "0x02000000",
         "0x04000000",
         "0x08000000",
         "0x10000000",
         "0x20000000",
         "0x40000000",
         "0x80000000",
     };

     /**
      * Classification constant: None.
      *
      * No additional information is available about the current motion event stream.
      *
      * @see #getClassification
      */
     public static final int CLASSIFICATION_NONE = 0;

     /**
      * Classification constant: Ambiguous gesture.
      *
      * The user's intent with respect to the current event stream is not yet determined.
      * Gestural actions, such as scrolling, should be inhibited until the classification resolves
      * to another value or the event stream ends.
      *
      * @see #getClassification
      */
     public static final int CLASSIFICATION_AMBIGUOUS_GESTURE = 1;

     /**
      * Classification constant: Deep press.
      *
      * The current event stream represents the user intentionally pressing harder on the screen.
      * This classification type should be used to accelerate the long press behaviour.
      *
      * @see #getClassification
      */
     public static final int CLASSIFICATION_DEEP_PRESS = 2;

     /**
      * Classification constant: touchpad scroll.
      *
      * The current event stream represents the user scrolling with two fingers on a touchpad.
      *
      * @see #getClassification
      */
     public static final int CLASSIFICATION_TWO_FINGER_SWIPE = 3;

     /**
      * Classification constant: multi-finger swipe.
      *
      * The current event stream represents the user swiping with three or more fingers on a
      * touchpad. Unlike two-finger swipes, these are only to be handled by the system UI, which is
      * why they have a separate constant from two-finger swipes.
      *
      * @see #getClassification
      * @hide
      */
     public static final int CLASSIFICATION_MULTI_FINGER_SWIPE = 4;

     /**
      * Classification constant: touchpad pinch.
      *
      * The current event stream represents the user pinching with two fingers on a touchpad. The
      * gesture is centered around the current cursor position.
      *
      * @see #getClassification
      */
     public static final int CLASSIFICATION_PINCH = 5;

     /** @hide */
     @Retention(SOURCE)
     @IntDef(prefix = { "CLASSIFICATION" }, value = {
             CLASSIFICATION_NONE, CLASSIFICATION_AMBIGUOUS_GESTURE, CLASSIFICATION_DEEP_PRESS,
             CLASSIFICATION_TWO_FINGER_SWIPE, CLASSIFICATION_MULTI_FINGER_SWIPE,
             CLASSIFICATION_PINCH})
     public @interface Classification {};

     /**
      * Tool type constant: Unknown tool type.
      * This constant is used when the tool type is not known or is not relevant,
      * such as for a trackball or other non-pointing device.
      *
      * @see #getToolType
      */
     public static final int TOOL_TYPE_UNKNOWN = 0;

     /**
      * Tool type constant: The tool is a finger.
      *
      * @see #getToolType
      */
     public static final int TOOL_TYPE_FINGER = 1;

     /**
      * Tool type constant: The tool is a stylus.
      *
      * @see #getToolType
      */
     public static final int TOOL_TYPE_STYLUS = 2;

     /**
      * Tool type constant: The tool is a mouse.
      *
      * @see #getToolType
      */
     public static final int TOOL_TYPE_MOUSE = 3;

     /**
      * Tool type constant: The tool is an eraser or a stylus being used in an inverted posture.
      *
      * @see #getToolType
      */
     public static final int TOOL_TYPE_ERASER = 4;

     /**
      * Tool type constant: The tool is a palm and should be rejected.
      *
      * @see #getToolType
      *
      * @hide
      */
     public static final int TOOL_TYPE_PALM = 5;

     /** @hide */
     @Retention(SOURCE)
     @IntDef(prefix = { "TOOL_TYPE_" }, value = {
             TOOL_TYPE_UNKNOWN, TOOL_TYPE_FINGER, TOOL_TYPE_STYLUS, TOOL_TYPE_MOUSE,
             TOOL_TYPE_ERASER, TOOL_TYPE_PALM})
     public @interface ToolType {};

     // NOTE: If you add a new tool type here you must also add it to:
     //  native/include/android/input.h

     // Symbolic names of all tool types.
     private static final SparseArray<String> TOOL_TYPE_SYMBOLIC_NAMES = new SparseArray<String>();
     static {
         SparseArray<String> names = TOOL_TYPE_SYMBOLIC_NAMES;
         names.append(TOOL_TYPE_UNKNOWN, "TOOL_TYPE_UNKNOWN");
         names.append(TOOL_TYPE_FINGER, "TOOL_TYPE_FINGER");
         names.append(TOOL_TYPE_STYLUS, "TOOL_TYPE_STYLUS");
         names.append(TOOL_TYPE_MOUSE, "TOOL_TYPE_MOUSE");
         names.append(TOOL_TYPE_ERASER, "TOOL_TYPE_ERASER");
     }

     // Private value for history pos that obtains the current sample.
     @UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.R, trackingBug = 170729553)
     private static final int HISTORY_CURRENT = -0x80000000;

     // This is essentially the same as native AMOTION_EVENT_INVALID_CURSOR_POSITION as they're all
     // NaN and we use isnan() everywhere to check validity.
     private static final float INVALID_CURSOR_POSITION = Float.NaN;

     private static final int MAX_RECYCLED = 10;
     private static final Object gRecyclerLock = new Object();
     private static int gRecyclerUsed;
     private static MotionEvent gRecyclerTop;

     // Shared temporary objects used when translating coordinates supplied by
     // the caller into single element PointerCoords and pointer id arrays.
     private static final Object gSharedTempLock = new Object();
     private static PointerCoords[] gSharedTempPointerCoords;
     private static PointerProperties[] gSharedTempPointerProperties;
     private static int[] gSharedTempPointerIndexMap;

     private static final void ensureSharedTempPointerCapacity(int desiredCapacity) {
         if (gSharedTempPointerCoords == null
                 || gSharedTempPointerCoords.length < desiredCapacity) {
             int capacity = gSharedTempPointerCoords != null ? gSharedTempPointerCoords.length : 8;
             while (capacity < desiredCapacity) {
                 capacity *= 2;
             }
             gSharedTempPointerCoords = PointerCoords.createArray(capacity);
             gSharedTempPointerProperties = PointerProperties.createArray(capacity);
             gSharedTempPointerIndexMap = new int[capacity];
         }
     }

     // Pointer to the native MotionEvent object that contains the actual data.
     @UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.P)
     private long mNativePtr;

     private MotionEvent mNext;

     private static native long nativeInitialize(long nativePtr,
             int deviceId, int source, int displayId, int action, int flags, int edgeFlags,
             int metaState, int buttonState, @Classification int classification,
             float xOffset, float yOffset, float xPrecision, float yPrecision,
             long downTimeNanos, long eventTimeNanos,
             int pointerCount, PointerProperties[] pointerIds, PointerCoords[] pointerCoords);
     private static native void nativeDispose(long nativePtr);
     private static native void nativeAddBatch(long nativePtr, long eventTimeNanos,
             PointerCoords[] pointerCoords, int metaState);
     private static native void nativeGetPointerCoords(long nativePtr,
             int pointerIndex, int historyPos, PointerCoords outPointerCoords);
     private static native void nativeGetPointerProperties(long nativePtr,
             int pointerIndex, PointerProperties outPointerProperties);

     private static native long nativeReadFromParcel(long nativePtr, Parcel parcel);
     private static native void nativeWriteToParcel(long nativePtr, Parcel parcel);

     private static native String nativeAxisToString(int axis);
     private static native int nativeAxisFromString(String label);

     // -------------- @FastNative -------------------------

     @FastNative
     private static native int nativeGetPointerId(long nativePtr, int pointerIndex);
     @FastNative
     private static native int nativeGetToolType(long nativePtr, int pointerIndex);
     @FastNative
     private static native long nativeGetEventTimeNanos(long nativePtr, int historyPos);
     @FastNative
     @UnsupportedAppUsage
     private static native float nativeGetRawAxisValue(long nativePtr,
             int axis, int pointerIndex, int historyPos);
     @FastNative
     private static native float nativeGetAxisValue(long nativePtr,
             int axis, int pointerIndex, int historyPos);
     @FastNative
     private static native void nativeTransform(long nativePtr, Matrix matrix);
     @FastNative
     private static native void nativeApplyTransform(long nativePtr, Matrix matrix);

     // -------------- @CriticalNative ----------------------

     @CriticalNative
     private static native long nativeCopy(long destNativePtr, long sourceNativePtr,
             boolean keepHistory);
     @CriticalNative
     private static native long nativeSplit(long destNativePtr, long sourceNativePtr, int idBits);
     @CriticalNative
     private static native int nativeGetId(long nativePtr);
     @CriticalNative
     private static native int nativeGetDeviceId(long nativePtr);
     @CriticalNative
     private static native int nativeGetSource(long nativePtr);
     @CriticalNative
     private static native void nativeSetSource(long nativePtr, int source);
     @CriticalNative
     private static native int nativeGetDisplayId(long nativePtr);
     @CriticalNative
     private static native void nativeSetDisplayId(long nativePtr, int displayId);
     @CriticalNative
     private static native int nativeGetAction(long nativePtr);
     @CriticalNative
     private static native void nativeSetAction(long nativePtr, int action);
     @CriticalNative
     private static native boolean nativeIsTouchEvent(long nativePtr);
     @CriticalNative
     private static native int nativeGetFlags(long nativePtr);
     @CriticalNative
     private static native void nativeSetFlags(long nativePtr, int flags);
     @CriticalNative
     private static native int nativeGetEdgeFlags(long nativePtr);
     @CriticalNative
     private static native void nativeSetEdgeFlags(long nativePtr, int action);
     @CriticalNative
     private static native int nativeGetMetaState(long nativePtr);
     @CriticalNative
     private static native int nativeGetButtonState(long nativePtr);
     @CriticalNative
     private static native void nativeSetButtonState(long nativePtr, int buttonState);
     @CriticalNative
     private static native int nativeGetClassification(long nativePtr);
     @CriticalNative
     private static native int nativeGetActionButton(long nativePtr);
     @CriticalNative
     private static native void nativeSetActionButton(long nativePtr, int actionButton);
     @CriticalNative
     private static native void nativeOffsetLocation(long nativePtr, float deltaX, float deltaY);
     @CriticalNative
     private static native float nativeGetRawXOffset(long nativePtr);
     @CriticalNative
     private static native float nativeGetRawYOffset(long nativePtr);
     @CriticalNative
     private static native float nativeGetXPrecision(long nativePtr);
     @CriticalNative
     private static native float nativeGetYPrecision(long nativePtr);
     @CriticalNative
     private static native float nativeGetXCursorPosition(long nativePtr);
     @CriticalNative
     private static native float nativeGetYCursorPosition(long nativePtr);
     @CriticalNative
     private static native void nativeSetCursorPosition(long nativePtr, float x, float y);
     @CriticalNative
     private static native long nativeGetDownTimeNanos(long nativePtr);
     @CriticalNative
     private static native void nativeSetDownTimeNanos(long nativePtr, long downTime);

     @CriticalNative
     private static native int nativeGetPointerCount(long nativePtr);
     @CriticalNative
     private static native int nativeFindPointerIndex(long nativePtr, int pointerId);

     @CriticalNative
     private static native int nativeGetHistorySize(long nativePtr);

     @CriticalNative
     private static native void nativeScale(long nativePtr, float scale);

     @CriticalNative
     private static native int nativeGetSurfaceRotation(long nativePtr);

     private MotionEvent() {
     }

     @Override
     protected void finalize() throws Throwable {
         try {
             if (mNativePtr != 0) {
                 nativeDispose(mNativePtr);
                 mNativePtr = 0;
             }
         } finally {
             super.finalize();
         }
     }

     @UnsupportedAppUsage
     static private MotionEvent obtain() {
         final MotionEvent ev;
         synchronized (gRecyclerLock) {
             ev = gRecyclerTop;
             if (ev == null) {
                 return new MotionEvent();
             }
             gRecyclerTop = ev.mNext;
             gRecyclerUsed -= 1;
         }
         ev.mNext = null;
         ev.prepareForReuse();
         return ev;
     }

     /**
      * Create a new MotionEvent, filling in all of the basic values that
      * define the motion.
      *
      * @param downTime The time (in ms) when the user originally pressed down to start
      * a stream of position events.  This must be obtained from {@link SystemClock#uptimeMillis()}.
      * @param eventTime The time (in ms) when this specific event was generated.  This
      * must be obtained from {@link SystemClock#uptimeMillis()}.
      * @param action The kind of action being performed, such as {@link #ACTION_DOWN}.
      * @param pointerCount The number of pointers that will be in this event.
      * @param pointerProperties An array of <em>pointerCount</em> values providing
      * a {@link PointerProperties} property object for each pointer, which must
      * include the pointer identifier.
      * @param pointerCoords An array of <em>pointerCount</em> values providing
      * a {@link PointerCoords} coordinate object for each pointer.
      * @param metaState The state of any meta / modifier keys that were in effect when
      * the event was generated.
      * @param buttonState The state of buttons that are pressed.
      * @param xPrecision The precision of the X coordinate being reported.
      * @param yPrecision The precision of the Y coordinate being reported.
      * @param deviceId The ID for the device that this event came from.  An ID of
      * zero indicates that the event didn't come from a physical device; other
      * numbers are arbitrary and you shouldn't depend on the values.
      * @param edgeFlags A bitfield indicating which edges, if any, were touched by this
      * MotionEvent.
      * @param source The source of this event.
      * @param displayId The display ID associated with this event.
      * @param flags The motion event flags.
      * @param classification The classification to give this event.
      */
     public static @Nullable MotionEvent obtain(long downTime, long eventTime, int action,
             int pointerCount,
             @SuppressLint("ArrayReturn") @NonNull PointerProperties[] pointerProperties,
             @SuppressLint("ArrayReturn") @NonNull PointerCoords[] pointerCoords, int metaState,
             int buttonState, float xPrecision, float yPrecision, int deviceId, int edgeFlags,
             int source, int displayId, int flags, @Classification int classification) {
         MotionEvent ev = obtain();
         final boolean success = ev.initialize(deviceId, source, displayId, action, flags, edgeFlags,
                 metaState, buttonState, classification, 0, 0, xPrecision, yPrecision,
                 downTime * NS_PER_MS, eventTime * NS_PER_MS, pointerCount, pointerProperties,
                 pointerCoords);
         if (!success) {
             Log.e(TAG, "Could not initialize MotionEvent");
             ev.recycle();
             return null;
         }
         return ev;
     }

     /**
      * Create a new MotionEvent, filling in all of the basic values that
      * define the motion.
      *
      * @param downTime The time (in ms) when the user originally pressed down to start
      * a stream of position events.  This must be obtained from {@link SystemClock#uptimeMillis()}.
      * @param eventTime The time (in ms) when this specific event was generated.  This
      * must be obtained from {@link SystemClock#uptimeMillis()}.
      * @param action The kind of action being performed, such as {@link #ACTION_DOWN}.
      * @param pointerCount The number of pointers that will be in this event.
      * @param pointerProperties An array of <em>pointerCount</em> values providing
      * a {@link PointerProperties} property object for each pointer, which must
      * include the pointer identifier.
      * @param pointerCoords An array of <em>pointerCount</em> values providing
      * a {@link PointerCoords} coordinate object for each pointer.
      * @param metaState The state of any meta / modifier keys that were in effect when
      * the event was generated.
      * @param buttonState The state of buttons that are pressed.
      * @param xPrecision The precision of the X coordinate being reported.
      * @param yPrecision The precision of the Y coordinate being reported.
      * @param deviceId The ID for the device that this event came from.  An ID of
      * zero indicates that the event didn't come from a physical device; other
      * numbers are arbitrary and you shouldn't depend on the values.
      * @param edgeFlags A bitfield indicating which edges, if any, were touched by this
      * MotionEvent.
      * @param source The source of this event.
      * @param displayId The display ID associated with this event.
      * @param flags The motion event flags.
      * @hide
      */
     public static MotionEvent obtain(long downTime, long eventTime,
             int action, int pointerCount, PointerProperties[] pointerProperties,
             PointerCoords[] pointerCoords, int metaState, int buttonState,
             float xPrecision, float yPrecision, int deviceId,
             int edgeFlags, int source, int displayId, int flags) {
         return obtain(downTime, eventTime, action, pointerCount, pointerProperties, pointerCoords,
                 metaState, buttonState, xPrecision, yPrecision, deviceId, edgeFlags, source,
                 displayId, flags, CLASSIFICATION_NONE);
     }

     /**
      * Create a new MotionEvent, filling in all of the basic values that
      * define the motion.
      *
      * @param downTime The time (in ms) when the user originally pressed down to start
      * a stream of position events.  This must be obtained from {@link SystemClock#uptimeMillis()}.
      * @param eventTime The time (in ms) when this specific event was generated.  This
      * must be obtained from {@link SystemClock#uptimeMillis()}.
      * @param action The kind of action being performed, such as {@link #ACTION_DOWN}.
      * @param pointerCount The number of pointers that will be in this event.
      * @param pointerProperties An array of <em>pointerCount</em> values providing
      * a {@link PointerProperties} property object for each pointer, which must
      * include the pointer identifier.
      * @param pointerCoords An array of <em>pointerCount</em> values providing
      * a {@link PointerCoords} coordinate object for each pointer.
      * @param metaState The state of any meta / modifier keys that were in effect when
      * the event was generated.
      * @param buttonState The state of buttons that are pressed.
      * @param xPrecision The precision of the X coordinate being reported.
      * @param yPrecision The precision of the Y coordinate being reported.
      * @param deviceId The ID for the device that this event came from.  An ID of
      * zero indicates that the event didn't come from a physical device; other
      * numbers are arbitrary and you shouldn't depend on the values.
      * @param edgeFlags A bitfield indicating which edges, if any, were touched by this
      * MotionEvent.
      * @param source The source of this event.
      * @param flags The motion event flags.
      */
     public static MotionEvent obtain(long downTime, long eventTime,
             int action, int pointerCount, PointerProperties[] pointerProperties,
             PointerCoords[] pointerCoords, int metaState, int buttonState,
             float xPrecision, float yPrecision, int deviceId,
             int edgeFlags, int source, int flags) {
         return obtain(downTime, eventTime, action, pointerCount, pointerProperties, pointerCoords,
                 metaState, buttonState, xPrecision, yPrecision, deviceId, edgeFlags, source,
                 DEFAULT_DISPLAY, flags);
     }

     /**
      * Create a new MotionEvent, filling in all of the basic values that
      * define the motion.
      *
      * @param downTime The time (in ms) when the user originally pressed down to start
      * a stream of position events.  This must be obtained from {@link SystemClock#uptimeMillis()}.
      * @param eventTime The time (in ms) when this specific event was generated.  This
      * must be obtained from {@link SystemClock#uptimeMillis()}.
      * @param action The kind of action being performed, such as {@link #ACTION_DOWN}.
      * @param pointerCount The number of pointers that will be in this event.
      * @param pointerIds An array of <em>pointerCount</em> values providing
      * an identifier for each pointer.
      * @param pointerCoords An array of <em>pointerCount</em> values providing
      * a {@link PointerCoords} coordinate object for each pointer.
      * @param metaState The state of any meta / modifier keys that were in effect when
      * the event was generated.
      * @param xPrecision The precision of the X coordinate being reported.
      * @param yPrecision The precision of the Y coordinate being reported.
      * @param deviceId The ID for the device that this event came from.  An ID of
      * zero indicates that the event didn't come from a physical device; other
      * numbers are arbitrary and you shouldn't depend on the values.
      * @param edgeFlags A bitfield indicating which edges, if any, were touched by this
      * MotionEvent.
      * @param source The source of this event.
      * @param flags The motion event flags.
      *
      * @deprecated Use {@link #obtain(long, long, int, int, PointerProperties[], PointerCoords[], int, int, float, float, int, int, int, int)}
      * instead.
      */
     @Deprecated
     static public MotionEvent obtain(long downTime, long eventTime,
             int action, int pointerCount, int[] pointerIds, PointerCoords[] pointerCoords,
             int metaState, float xPrecision, float yPrecision, int deviceId,
             int edgeFlags, int source, int flags) {
         synchronized (gSharedTempLock) {
             ensureSharedTempPointerCapacity(pointerCount);
             final PointerProperties[] pp = gSharedTempPointerProperties;
             for (int i = 0; i < pointerCount; i++) {
                 pp[i].clear();
                 pp[i].id = pointerIds[i];
             }
             return obtain(downTime, eventTime, action, pointerCount, pp,
                     pointerCoords, metaState, 0, xPrecision, yPrecision, deviceId,
                     edgeFlags, source, flags);
         }
     }

     /**
      * Create a new MotionEvent, filling in all of the basic values that
      * define the motion.
      *
      * @param downTime The time (in ms) when the user originally pressed down to start
      * a stream of position events.  This must be obtained from {@link SystemClock#uptimeMillis()}.
      * @param eventTime The time (in ms) when this specific event was generated.  This
      * must be obtained from {@link SystemClock#uptimeMillis()}.
      * @param action The kind of action being performed, such as {@link #ACTION_DOWN}.
      * @param x The X coordinate of this event.
      * @param y The Y coordinate of this event.
      * @param pressure The current pressure of this event.  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
      * the input device.
      * @param size A scaled value of the approximate size of the area being pressed when
      * touched with the finger. The actual value in pixels corresponding to the finger
      * touch is normalized with a device specific range of values
      * and scaled to a value between 0 and 1.
      * @param metaState The state of any meta / modifier keys that were in effect when
      * the event was generated.
      * @param xPrecision The precision of the X coordinate being reported.
      * @param yPrecision The precision of the Y coordinate being reported.
      * @param deviceId The ID for the device that this event came from.  An ID of
      * zero indicates that the event didn't come from a physical device; other
      * numbers are arbitrary and you shouldn't depend on the values.
      * @param edgeFlags A bitfield indicating which edges, if any, were touched by this
      * MotionEvent.
      */
     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) {
         return obtain(downTime, eventTime, action, x, y, pressure, size, metaState,
                 xPrecision, yPrecision, deviceId, edgeFlags, InputDevice.SOURCE_CLASS_POINTER,
                 DEFAULT_DISPLAY);
     }

     /**
      * Create a new MotionEvent, filling in all of the basic values that
      * define the motion.
      *
      * @param downTime The time (in ms) when the user originally pressed down to start
      * a stream of position events.  This must be obtained from {@link SystemClock#uptimeMillis()}.
      * @param eventTime The time (in ms) when this specific event was generated.  This
      * must be obtained from {@link SystemClock#uptimeMillis()}.
      * @param action The kind of action being performed, such as {@link #ACTION_DOWN}.
      * @param x The X coordinate of this event.
      * @param y The Y coordinate of this event.
      * @param pressure The current pressure of this event.  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
      * the input device.
      * @param size A scaled value of the approximate size of the area being pressed when
      * touched with the finger. The actual value in pixels corresponding to the finger
      * touch is normalized with a device specific range of values
      * and scaled to a value between 0 and 1.
      * @param metaState The state of any meta / modifier keys that were in effect when
      * the event was generated.
      * @param xPrecision The precision of the X coordinate being reported.
      * @param yPrecision The precision of the Y coordinate being reported.
      * @param deviceId The ID for the device that this event came from.  An ID of
      * zero indicates that the event didn't come from a physical device; other
      * numbers are arbitrary and you shouldn't depend on the values.
      * @param source The source of this event.
      * @param edgeFlags A bitfield indicating which edges, if any, were touched by this
      * MotionEvent.
      * @param displayId The display ID associated with this event.
      * @hide
      */
     public static 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, int source,
             int displayId) {
         MotionEvent ev = obtain();
         synchronized (gSharedTempLock) {
             ensureSharedTempPointerCapacity(1);
             final PointerProperties[] pp = gSharedTempPointerProperties;
             pp[0].clear();
             pp[0].id = 0;

             final PointerCoords pc[] = gSharedTempPointerCoords;
             pc[0].clear();
             pc[0].x = x;
             pc[0].y = y;
             pc[0].pressure = pressure;
             pc[0].size = size;

             ev.initialize(deviceId, source, displayId,
                     action, 0, edgeFlags, metaState, 0 /*buttonState*/, CLASSIFICATION_NONE,
                     0, 0, xPrecision, yPrecision,
                     downTime * NS_PER_MS, eventTime * NS_PER_MS,
                     1, pp, pc);
             return ev;
         }
     }

     /**
      * Create a new MotionEvent, filling in all of the basic values that
      * define the motion.
      *
      * @param downTime The time (in ms) when the user originally pressed down to start
      * a stream of position events.  This must be obtained from {@link SystemClock#uptimeMillis()}.
      * @param eventTime The time (in ms) when this specific event was generated.  This
      * must be obtained from {@link SystemClock#uptimeMillis()}.
      * @param action The kind of action being performed, such as {@link #ACTION_DOWN}.
      * @param pointerCount The number of pointers that are active in this event.
      * @param x The X coordinate of this event.
      * @param y The Y coordinate of this event.
      * @param pressure The current pressure of this event.  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
      * the input device.
      * @param size A scaled value of the approximate size of the area being pressed when
      * touched with the finger. The actual value in pixels corresponding to the finger
      * touch is normalized with a device specific range of values
      * and scaled to a value between 0 and 1.
      * @param metaState The state of any meta / modifier keys that were in effect when
      * the event was generated.
      * @param xPrecision The precision of the X coordinate being reported.
      * @param yPrecision The precision of the Y coordinate being reported.
      * @param deviceId The ID for the device that this event came from.  An ID of
      * zero indicates that the event didn't come from a physical device; other
      * numbers are arbitrary and you shouldn't depend on the values.
      * @param edgeFlags A bitfield indicating which edges, if any, were touched by this
      * MotionEvent.
      *
      * @deprecated Use {@link #obtain(long, long, int, float, float, float, float, int, float, float, int, int)}
      * instead.
      */
     @Deprecated
     static public MotionEvent obtain(long downTime, long eventTime, int action,
             int pointerCount, float x, float y, float pressure, float size, int metaState,
             float xPrecision, float yPrecision, int deviceId, int edgeFlags) {
         return obtain(downTime, eventTime, action, x, y, pressure, size,
                 metaState, xPrecision, yPrecision, deviceId, edgeFlags);
     }

     /**
      * Create a new MotionEvent, filling in a subset of the basic motion
      * values.  Those not specified here are: device id (always 0), pressure
      * and size (always 1), x and y precision (always 1), and edgeFlags (always 0).
      *
      * @param downTime The time (in ms) when the user originally pressed down to start
      * a stream of position events.  This must be obtained from {@link SystemClock#uptimeMillis()}.
      * @param eventTime The time (in ms) when this specific event was generated.  This
      * must be obtained from {@link SystemClock#uptimeMillis()}.
      * @param action The kind of action being performed, such as {@link #ACTION_DOWN}.
      * @param x The X coordinate of this event.
      * @param y The Y coordinate of this event.
      * @param metaState The state of any meta / modifier keys that were in effect when
      * the event was generated.
      */
     static public MotionEvent obtain(long downTime, long eventTime, int action,
             float x, float y, int metaState) {
         return obtain(downTime, eventTime, action, x, y, 1.0f, 1.0f,
                 metaState, 1.0f, 1.0f, 0, 0);
     }

     /**
      * Create a new MotionEvent, copying from an existing one.
      */
     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;
     }

     /**
      * Create a new MotionEvent, copying from an existing one, but not including
      * any historical point information.
      */
     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;
     }

     private boolean initialize(int deviceId, int source, int displayId, int action, int flags,
             int edgeFlags, int metaState, int buttonState, @Classification int classification,
             float xOffset, float yOffset, float xPrecision, float yPrecision,
             long downTimeNanos, long eventTimeNanos,
             int pointerCount, PointerProperties[] pointerIds, PointerCoords[] pointerCoords) {
         if (action == ACTION_CANCEL) {
             flags |= FLAG_CANCELED;
         }
         mNativePtr = nativeInitialize(mNativePtr, deviceId, source, displayId, action, flags,
                 edgeFlags, metaState, buttonState, classification, xOffset, yOffset,
                 xPrecision, yPrecision, downTimeNanos, eventTimeNanos, pointerCount, pointerIds,
                 pointerCoords);
         if (mNativePtr == 0) {
             return false;
         }
         updateCursorPosition();
         return true;
     }

     /** @hide */
     @Override
     @UnsupportedAppUsage
     public MotionEvent copy() {
         return obtain(this);
     }

     /**
      * Recycle the MotionEvent, to be re-used by a later caller.  After calling
      * this function you must not ever touch the event again.
      */
     @Override
     public final void recycle() {
         super.recycle();

         synchronized (gRecyclerLock) {
             if (gRecyclerUsed < MAX_RECYCLED) {
                 gRecyclerUsed++;
                 mNext = gRecyclerTop;
                 gRecyclerTop = this;
             }
         }
     }

     /**
      * Applies a scale factor to all points within this event.
      *
      * This method is used to adjust touch events to simulate different density
      * displays for compatibility mode.  The values returned by {@link #getRawX()},
      * {@link #getRawY()}, {@link #getXPrecision()} and {@link #getYPrecision()}
      * are also affected by the scale factor.
      *
      * @param scale The scale factor to apply.
      * @hide
      */
     @UnsupportedAppUsage
     public final void scale(float scale) {
         if (scale != 1.0f) {
             nativeScale(mNativePtr, scale);
         }
     }

     /** @hide */
     @Override
     public int getId() {
         return nativeGetId(mNativePtr);
     }

     /** {@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) {
         if (source == getSource()) {
             return;
         }
         nativeSetSource(mNativePtr, source);
         updateCursorPosition();
     }

     /** @hide */
     @TestApi
     @Override
     public int getDisplayId() {
         return nativeGetDisplayId(mNativePtr);
     }

     /** @hide */
     @TestApi
     @Override
     public void setDisplayId(int displayId) {
         nativeSetDisplayId(mNativePtr, displayId);
     }

     /**
      * Return the kind of action being performed.
      * Consider using {@link #getActionMasked} and {@link #getActionIndex} to retrieve
      * the separate masked action and pointer index.
      * @return The action, such as {@link #ACTION_DOWN} or
      * the combination of {@link #ACTION_POINTER_DOWN} with a shifted pointer index.
      */
     public final int getAction() {
         return nativeGetAction(mNativePtr);
     }

     /**
      * Return the masked action being performed, without pointer index information.
      * Use {@link #getActionIndex} to return the index associated with pointer actions.
      * @return The action, such as {@link #ACTION_DOWN} or {@link #ACTION_POINTER_DOWN}.
      */
     public final int getActionMasked() {
         return nativeGetAction(mNativePtr) & ACTION_MASK;
     }

     /**
      * For {@link #ACTION_POINTER_DOWN} or {@link #ACTION_POINTER_UP}
      * as returned by {@link #getActionMasked}, this returns the associated
      * pointer index.
      * The index may be used with {@link #getPointerId(int)},
      * {@link #getX(int)}, {@link #getY(int)}, {@link #getPressure(int)},
      * and {@link #getSize(int)} to get information about the pointer that has
      * gone down or up.
      * @return The index associated with the action.
      */
     public final int getActionIndex() {
         return (nativeGetAction(mNativePtr) & ACTION_POINTER_INDEX_MASK)
                 >> ACTION_POINTER_INDEX_SHIFT;
     }

     /**
      * Returns true if this motion event is a touch event.
      * <p>
      * Specifically excludes pointer events with action {@link #ACTION_HOVER_MOVE},
      * {@link #ACTION_HOVER_ENTER}, {@link #ACTION_HOVER_EXIT}, or {@link #ACTION_SCROLL}
      * because they are not actually touch events (the pointer is not down).
      * </p>
      * @return True if this motion event is a touch event.
      * @hide
      */
     public final boolean isTouchEvent() {
         return nativeIsTouchEvent(mNativePtr);
     }

     /**
      * Returns {@code true} if this motion event is from a stylus pointer.
      * @hide
      */
     public boolean isStylusPointer() {
         final int actionIndex = getActionIndex();
         return isFromSource(InputDevice.SOURCE_STYLUS)
                 && (getToolType(actionIndex) == TOOL_TYPE_STYLUS
                 || getToolType(actionIndex) == TOOL_TYPE_ERASER);
     }

     /**
      * Returns {@code true} if this motion event is a hover event, identified by it having an action
      * of either {@link #ACTION_HOVER_ENTER}, {@link #ACTION_HOVER_MOVE} or
      * {@link #ACTION_HOVER_EXIT}.
      * @hide
      */
     public boolean isHoverEvent() {
         return getActionMasked() == ACTION_HOVER_ENTER
                 || getActionMasked() == ACTION_HOVER_EXIT
                 || getActionMasked() == ACTION_HOVER_MOVE;
     }

     /**
      * Gets the motion event flags.
      *
      * @see #FLAG_WINDOW_IS_OBSCURED
      */
     public final int getFlags() {
         return nativeGetFlags(mNativePtr);
     }

     /** @hide */
     @Override
     public final boolean isTainted() {
         final int flags = getFlags();
         return (flags & FLAG_TAINTED) != 0;
     }

     /** @hide */
     @Override
     public final void setTainted(boolean tainted) {
         final int flags = getFlags();
         nativeSetFlags(mNativePtr, tainted ? flags | FLAG_TAINTED : flags & ~FLAG_TAINTED);
     }

     private void setCanceled(boolean canceled) {
         final int flags = getFlags();
         nativeSetFlags(mNativePtr, canceled ? flags | FLAG_CANCELED : flags & ~FLAG_CANCELED);
     }

     /** @hide */
     public  boolean isTargetAccessibilityFocus() {
         final int flags = getFlags();
         return (flags & FLAG_TARGET_ACCESSIBILITY_FOCUS) != 0;
     }

     /** @hide */
     public void setTargetAccessibilityFocus(boolean targetsFocus) {
         final int flags = getFlags();
         nativeSetFlags(mNativePtr, targetsFocus
                 ? flags | FLAG_TARGET_ACCESSIBILITY_FOCUS
                 : flags & ~FLAG_TARGET_ACCESSIBILITY_FOCUS);
     }

     /** @hide */
     public final boolean isHoverExitPending() {
         final int flags = getFlags();
         return (flags & FLAG_HOVER_EXIT_PENDING) != 0;
     }

     /** @hide */
     public void setHoverExitPending(boolean hoverExitPending) {
         final int flags = getFlags();
         nativeSetFlags(mNativePtr, hoverExitPending
                 ? flags | FLAG_HOVER_EXIT_PENDING
                 : flags & ~FLAG_HOVER_EXIT_PENDING);
     }

     /**
      * Returns the time (in ms) when the user originally pressed down to start
      * a stream of position events.
      */
     public final long getDownTime() {
         return nativeGetDownTimeNanos(mNativePtr) / NS_PER_MS;
     }

     /**
      * Sets the time (in ms) when the user originally pressed down to start
      * a stream of position events.
      *
      * @hide
      */
     @UnsupportedAppUsage
     public final void setDownTime(long downTime) {
         nativeSetDownTimeNanos(mNativePtr, downTime * NS_PER_MS);
     }

     /**
      * Retrieve the time this event occurred,
      * in the {@link android.os.SystemClock#uptimeMillis} time base.
      *
      * @return Returns the time this event occurred,
      * in the {@link android.os.SystemClock#uptimeMillis} time base.
      */
     @Override
     public final long getEventTime() {
         return nativeGetEventTimeNanos(mNativePtr, HISTORY_CURRENT) / NS_PER_MS;
     }

     /**
      * Retrieve the time this event occurred,
      * in the {@link android.os.SystemClock#uptimeMillis} time base but with
      * nanosecond precision.
      * <p>
      * The value is in nanosecond precision but it may not have nanosecond accuracy.
      * </p>
      *
      * @return Returns the time this event occurred,
      * in the {@link android.os.SystemClock#uptimeMillis} time base but with
      * nanosecond precision.
      */
     @Override
     public long getEventTimeNanos() {
         return nativeGetEventTimeNanos(mNativePtr, HISTORY_CURRENT);
     }

     /**
      * Equivalent to {@link #getX(int)} for pointer index 0 (regardless of the
      * pointer identifier).
      *
      * @return The X coordinate of the first pointer index in the coordinate
      *      space of the view that received this motion event.
      *
      * @see #AXIS_X
      */
     public final float getX() {
         return nativeGetAxisValue(mNativePtr, AXIS_X, 0, HISTORY_CURRENT);
     }

     /**
      * Equivalent to {@link #getY(int)} for pointer index 0 (regardless of the
      * pointer identifier).
      *
      * @return The Y coordinate of the first pointer index in the coordinate
      *      space of the view that received this motion event.
      *
      * @see #AXIS_Y
      */
     public final float getY() {
         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 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 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 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 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 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 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 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);
     }

     /**
      * The number of pointers of data contained in this event.  Always
      * >= 1.
      */
     public final int getPointerCount() {
         return nativeGetPointerCount(mNativePtr);
     }

     /**
      * Return the pointer identifier associated with a particular pointer
      * data index in this event.  The identifier tells you the actual pointer
      * number associated with the data, accounting for individual pointers
      * going up and down since the start of the current gesture.
      * @param pointerIndex Raw index of pointer to retrieve.  Value may be from 0
      * (the first pointer that is down) to {@link #getPointerCount()}-1.
      */
     public final int getPointerId(int pointerIndex) {
         return nativeGetPointerId(mNativePtr, pointerIndex);
     }

     /**
      * Gets the tool type of a pointer for the given pointer index.
      * The tool type indicates the type of tool used to make contact such
      * as a finger or stylus, if known.
      *
      * @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 tool type of the pointer.
      *
      * @see #TOOL_TYPE_UNKNOWN
      * @see #TOOL_TYPE_FINGER
      * @see #TOOL_TYPE_STYLUS
      * @see #TOOL_TYPE_MOUSE
      */
     public @ToolType int getToolType(int pointerIndex) {
         return nativeGetToolType(mNativePtr, pointerIndex);
     }

     /**
      * Given a pointer identifier, find the index of its data in the event.
      *
      * @param pointerId The identifier of the pointer to be found.
      * @return Returns either the index of the pointer (for use with
      * {@link #getX(int)} et al.), or -1 if there is no data available for
      * that pointer identifier.
      */
     public final int findPointerIndex(int pointerId) {
         return nativeFindPointerIndex(mNativePtr, pointerId);
     }

     /**
      * Returns the X coordinate of the pointer referenced by
      * {@code pointerIndex} for this motion event. The coordinate is in the
      * coordinate space of the view that received this motion event.
      *
      * <p>Use {@link #getPointerId(int)} to get the pointer identifier for the
      * pointer referenced by {@code pointerIndex}.
      *
      * @param pointerIndex Index of the pointer for which the X coordinate is
      *      returned. May be a value in the range of 0 (the first pointer that
      *      is down) to {@link #getPointerCount()} - 1.
      * @return The X coordinate of the pointer referenced by
      *      {@code pointerIndex} for this motion event. The unit is pixels. The
      *      value may contain a fractional portion for devices that are subpixel
      *      precise.
      *
      * @see #AXIS_X
      */
     public final float getX(int pointerIndex) {
         return nativeGetAxisValue(mNativePtr, AXIS_X, pointerIndex, HISTORY_CURRENT);
     }

     /**
      * Returns the Y coordinate of the pointer referenced by
      * {@code pointerIndex} for this motion event. The coordinate is in the
      * coordinate space of the view that received this motion event.
      *
      * <p>Use {@link #getPointerId(int)} to get the pointer identifier for the
      * pointer referenced by {@code pointerIndex}.
      *
      * @param pointerIndex Index of the pointer for which the Y coordinate is
      *      returned. May be a value in the range of 0 (the first pointer that
      *      is down) to {@link #getPointerCount()} - 1.
      * @return The Y coordinate of the pointer referenced by
      *      {@code pointerIndex} for this motion event. The unit is pixels. The
      *      value may contain a fractional portion for devices that are subpixel
      *      precise.
      *
      * @see #AXIS_Y
      */
     public final float getY(int pointerIndex) {
         return nativeGetAxisValue(mNativePtr, AXIS_Y, pointerIndex, HISTORY_CURRENT);
     }

     /**
      * Returns the current pressure of this event for the given pointer
      * <em>index</em> (use {@link #getPointerId(int)} to find the pointer
      * identifier for this index).
      * 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
      * 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 nativeGetAxisValue(mNativePtr, AXIS_PRESSURE, pointerIndex, HISTORY_CURRENT);
     }

     /**
      * Returns a scaled value of the approximate size for the given pointer
      * <em>index</em> (use {@link #getPointerId(int)} to find the pointer
      * identifier for this index).
      * This 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.
      * @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 nativeGetAxisValue(mNativePtr, AXIS_SIZE, pointerIndex, HISTORY_CURRENT);
     }

     /**
      * Returns the length of the major axis of an ellipse that describes the touch
      * area at the point of contact for the given pointer
      * <em>index</em> (use {@link #getPointerId(int)} to find the pointer
      * 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 nativeGetAxisValue(mNativePtr, AXIS_TOUCH_MAJOR, pointerIndex, HISTORY_CURRENT);
     }

     /**
      * Returns the length of the minor axis of an ellipse that describes the touch
      * area at the point of contact for the given pointer
      * <em>index</em> (use {@link #getPointerId(int)} to find the pointer
      * 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 nativeGetAxisValue(mNativePtr, AXIS_TOUCH_MINOR, pointerIndex, HISTORY_CURRENT);
     }

     /**
      * Returns the length of the major axis of an ellipse that describes the size of
      * the approaching tool for the given pointer
      * <em>index</em> (use {@link #getPointerId(int)} to find the pointer
      * identifier for this index).
      * 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.
      * @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 nativeGetAxisValue(mNativePtr, AXIS_TOOL_MAJOR, pointerIndex, HISTORY_CURRENT);
     }

     /**
      * Returns the length of the minor axis of an ellipse that describes the size of
      * the approaching tool for the given pointer
      * <em>index</em> (use {@link #getPointerId(int)} to find the pointer
      * identifier for this index).
      * 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.
      * @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 nativeGetAxisValue(mNativePtr, AXIS_TOOL_MINOR, pointerIndex, HISTORY_CURRENT);
     }

     /**
      * Returns the orientation of the touch area and tool area in radians clockwise from vertical
      * for the given pointer <em>index</em> (use {@link #getPointerId(int)} to find the pointer
      * identifier for this index).
      * An angle of 0 radians 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).
      * @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 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.
      *
      * @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) {
         nativeGetPointerCoords(mNativePtr, pointerIndex, HISTORY_CURRENT, outPointerCoords);
     }

     /**
      * Populates a {@link PointerProperties} object with pointer properties for
      * the specified pointer index.
      *
      * @param pointerIndex Raw index of pointer to retrieve.  Value may be from 0
      * (the first pointer that is down) to {@link #getPointerCount()}-1.
      * @param outPointerProperties The pointer properties object to populate.
      *
      * @see PointerProperties
      */
     public final void getPointerProperties(int pointerIndex,
             PointerProperties outPointerProperties) {
         nativeGetPointerProperties(mNativePtr, pointerIndex, outPointerProperties);
     }

     /**
      * Returns the state of any meta / modifier keys that were in effect when
      * the event was generated.  This is the same values as those
      * returned by {@link KeyEvent#getMetaState() KeyEvent.getMetaState}.
      *
      * @return an integer in which each bit set to 1 represents a pressed
      *         meta key
      *
      * @see KeyEvent#getMetaState()
      */
     public final int getMetaState() {
         return nativeGetMetaState(mNativePtr);
     }

     /**
      * Gets the state of all buttons that are pressed such as a mouse or stylus button.
      *
      * @return The button state.
      *
      * @see #BUTTON_PRIMARY
      * @see #BUTTON_SECONDARY
      * @see #BUTTON_TERTIARY
      * @see #BUTTON_FORWARD
      * @see #BUTTON_BACK
      * @see #BUTTON_STYLUS_PRIMARY
      * @see #BUTTON_STYLUS_SECONDARY
      */
     public final int getButtonState() {
         return nativeGetButtonState(mNativePtr);
     }

     /**
      * Sets the bitfield indicating which buttons are pressed.
      *
      * @see #getButtonState()
      * @hide
      */
     @TestApi
     public final void setButtonState(int buttonState) {
         nativeSetButtonState(mNativePtr, buttonState);
     }

     /**
      * Returns the classification for the current gesture.
      * The classification may change as more events become available for the same gesture.
      *
      * @see #CLASSIFICATION_NONE
      * @see #CLASSIFICATION_AMBIGUOUS_GESTURE
      * @see #CLASSIFICATION_DEEP_PRESS
      */
     public @Classification int getClassification() {
         return nativeGetClassification(mNativePtr);
     }

     /**
      * Gets which button has been modified during a press or release action.
      *
      * For actions other than {@link #ACTION_BUTTON_PRESS} and {@link #ACTION_BUTTON_RELEASE}
      * the returned value is undefined.
      *
      * @see #getButtonState()
      */
     public final int getActionButton() {
         return nativeGetActionButton(mNativePtr);
     }

     /**
      * Sets the action button for the event.
      *
      * @see #getActionButton()
      * @hide
      */
     @UnsupportedAppUsage
     @TestApi
     public final void setActionButton(int button) {
         nativeSetActionButton(mNativePtr, button);
     }

     /**
      * Equivalent to {@link #getRawX(int)} for pointer index 0 (regardless of
      * the pointer identifier).
      *
      * @return The X coordinate of the first pointer index in the coordinate
      *      space of the device display.
      *
      * @see #getX()
      * @see #AXIS_X
      */
     public final float getRawX() {
         return nativeGetRawAxisValue(mNativePtr, AXIS_X, 0, HISTORY_CURRENT);
     }

     /**
      * Equivalent to {@link #getRawY(int)} for pointer index 0 (regardless of
      * the pointer identifier).
      *
      * @return The Y coordinate of the first pointer index in the coordinate
      *      space of the device display.
      *
      * @see #getY()
      * @see #AXIS_Y
      */
     public final float getRawY() {
         return nativeGetRawAxisValue(mNativePtr, AXIS_Y, 0, HISTORY_CURRENT);
     }

     /**
      * Returns the X coordinate of the pointer referenced by
      * {@code pointerIndex} for this motion event. The coordinate is in the
      * coordinate space of the device display, irrespective of system
      * decorations and whether or not the system is in multi-window mode. If the
      * app spans multiple screens in a multiple-screen environment, the
      * coordinate space includes all of the spanned screens.
      *
      * <p>In multi-window mode, the coordinate space extends beyond the bounds
      * of the app window to encompass the entire display area. For example, if
      * the motion event occurs in the right-hand window of split-screen mode in
      * landscape orientation, the left edge of the screen&mdash;not the left
      * edge of the window&mdash;is the origin from which the X coordinate is
      * calculated.
      *
      * <p>In multiple-screen scenarios, the coordinate space can span screens.
      * For example, if the app is spanning both screens of a dual-screen device,
      * and the motion event occurs on the right-hand screen, the X coordinate is
      * calculated from the left edge of the left-hand screen to the point of the
      * motion event on the right-hand screen. When the app is restricted to a
      * single screen in a multiple-screen environment, the coordinate space
      * includes only the screen on which the app is running.
      *
      * <p>Use {@link #getPointerId(int)} to get the pointer identifier for the
      * pointer referenced by {@code pointerIndex}.
      *
      * @param pointerIndex Index of the pointer for which the X coordinate is
      *      returned. May be a value in the range of 0 (the first pointer that
      *      is down) to {@link #getPointerCount()} - 1.
      * @return The X coordinate of the pointer referenced by
      *      {@code pointerIndex} for this motion event. The unit is pixels. The
      *      value may contain a fractional portion for devices that are subpixel
      *      precise.
      *
      * @see #getX(int)
      * @see #AXIS_X
      */
     public float getRawX(int pointerIndex) {
         return nativeGetRawAxisValue(mNativePtr, AXIS_X, pointerIndex, HISTORY_CURRENT);
     }

     /**
      * Returns the Y coordinate of the pointer referenced by
      * {@code pointerIndex} for this motion event. The coordinate is in the
      * coordinate space of the device display, irrespective of system
      * decorations and whether or not the system is in multi-window mode. If the
      * app spans multiple screens in a multiple-screen environment, the
      * coordinate space includes all of the spanned screens.
      *
      * <p>In multi-window mode, the coordinate space extends beyond the bounds
      * of the app window to encompass the entire device screen. For example, if
      * the motion event occurs in the lower window of split-screen mode in
      * portrait orientation, the top edge of the screen&mdash;not the top edge
      * of the window&mdash;is the origin from which the Y coordinate is
      * determined.
      *
      * <p>In multiple-screen scenarios, the coordinate space can span screens.
      * For example, if the app is spanning both screens of a dual-screen device
      * that's rotated 90 degrees, and the motion event occurs on the lower
      * screen, the Y coordinate is calculated from the top edge of the upper
      * screen to the point of the motion event on the lower screen. When the app
      * is restricted to a single screen in a multiple-screen environment, the
      * coordinate space includes only the screen on which the app is running.
      *
      * <p>Use {@link #getPointerId(int)} to get the pointer identifier for the
      * pointer referenced by {@code pointerIndex}.
      *
      * @param pointerIndex Index of the pointer for which the Y coordinate is
      *      returned. May be a value in the range of 0 (the first pointer that
      *      is down) to {@link #getPointerCount()} - 1.
      * @return The Y coordinate of the pointer referenced by
      *      {@code pointerIndex} for this motion event. The unit is pixels. The
      *      value may contain a fractional portion for devices that are subpixel
      *      precise.
      *
      * @see #getY(int)
      * @see #AXIS_Y
      */
     public float getRawY(int pointerIndex) {
         return nativeGetRawAxisValue(mNativePtr, AXIS_Y, pointerIndex, HISTORY_CURRENT);
     }

     /**
      * Return the precision of the X coordinates being reported.  You can
      * 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 nativeGetXPrecision(mNativePtr);
     }

     /**
      * Return the precision of the Y coordinates being reported.  You can
      * 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 nativeGetYPrecision(mNativePtr);
     }

     /**
      * Returns the x coordinate of mouse cursor position when this event is
      * reported. This value is only valid if {@link #getSource()} returns
      * {@link InputDevice#SOURCE_MOUSE}.
      *
      * @hide
      */
     public float getXCursorPosition() {
         return nativeGetXCursorPosition(mNativePtr);
     }

     /**
      * Returns the y coordinate of mouse cursor position when this event is
      * reported. This value is only valid if {@link #getSource()} returns
      * {@link InputDevice#SOURCE_MOUSE}.
      *
      * @hide
      */
     public float getYCursorPosition() {
         return nativeGetYCursorPosition(mNativePtr);
     }

     /**
      * Sets cursor position to given coordinates. The coordinate in parameters should be after
      * offsetting. In other words, the effect of this function is {@link #getXCursorPosition()} and
      * {@link #getYCursorPosition()} will return the same value passed in the parameters.
      *
      * @hide
      */
     private void setCursorPosition(float x, float y) {
         nativeSetCursorPosition(mNativePtr, x, y);
     }

     /**
      * Returns the number of historical points in this event.  These are
      * movements that have occurred between this event and the previous event.
      * This only applies to ACTION_MOVE events -- all other actions will have
      * a size of 0.
      *
      * @return Returns the number of historical points in the event.
      */
     public final int getHistorySize() {
         return nativeGetHistorySize(mNativePtr);
     }

     /**
      * Returns the time that a historical movement occurred between this event
      * and the previous event, in the {@link android.os.SystemClock#uptimeMillis} time base.
      * <p>
      * This only applies to ACTION_MOVE events.
      * </p>
      *
      * @param pos Which historical value to return; must be less than
      * {@link #getHistorySize}
      * @return Returns the time that a historical movement occurred between this
      * event and the previous event,
      * in the {@link android.os.SystemClock#uptimeMillis} time base.
      *
      * @see #getHistorySize
      * @see #getEventTime
      */
     public final long getHistoricalEventTime(int pos) {
         return nativeGetEventTimeNanos(mNativePtr, pos) / NS_PER_MS;
     }

     /**
      * Returns the time that a historical movement occurred between this event
      * and the previous event, in the {@link android.os.SystemClock#uptimeMillis} time base
      * but with nanosecond (instead of millisecond) precision.
      * <p>
      * This only applies to ACTION_MOVE events.
      * </p><p>
      * The value is in nanosecond precision but it may not have nanosecond accuracy.
      * </p>
      *
      * @param pos Which historical value to return; must be less than
      * {@link #getHistorySize}
      * @return Returns the time that a historical movement occurred between this
      * event and the previous event,
      * in the {@link android.os.SystemClock#uptimeMillis} time base but with
      * nanosecond (instead of millisecond) precision.
      *
      * @see #getHistorySize
      * @see #getEventTime
      */
     public long getHistoricalEventTimeNanos(int pos) {
         return nativeGetEventTimeNanos(mNativePtr, pos);
     }

     /**
      * {@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 nativeGetAxisValue(mNativePtr, AXIS_X, 0, pos);
     }

     /**
      * {@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 nativeGetAxisValue(mNativePtr, AXIS_Y, 0, pos);
     }

     /**
      * {@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 nativeGetAxisValue(mNativePtr, AXIS_PRESSURE, 0, pos);
     }

     /**
      * {@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 nativeGetAxisValue(mNativePtr, AXIS_SIZE, 0, pos);
     }

     /**
      * {@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 nativeGetAxisValue(mNativePtr, AXIS_TOUCH_MAJOR, 0, pos);
     }

     /**
      * {@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 nativeGetAxisValue(mNativePtr, AXIS_TOUCH_MINOR, 0, pos);
     }

     /**
      * {@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 nativeGetAxisValue(mNativePtr, AXIS_TOOL_MAJOR, 0, pos);
     }

     /**
      * {@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 nativeGetAxisValue(mNativePtr, AXIS_TOOL_MINOR, 0, pos);
     }

     /**
      * {@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 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.
      * Only applies to ACTION_MOVE events.
      *
      * @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}
      *
      * @see #getHistorySize
      * @see #getX(int)
      * @see #AXIS_X
      */
     public final float getHistoricalX(int pointerIndex, int pos) {
         return nativeGetAxisValue(mNativePtr, AXIS_X, pointerIndex, pos);
     }

     /**
      * Returns a historical Y coordinate, as per {@link #getY(int)}, that
      * occurred between this event and the previous event for the given pointer.
      * Only applies to ACTION_MOVE events.
      *
      * @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}
      *
      * @see #getHistorySize
      * @see #getY(int)
      * @see #AXIS_Y
      */
     public final float getHistoricalY(int pointerIndex, int pos) {
         return nativeGetAxisValue(mNativePtr, AXIS_Y, pointerIndex, pos);
     }

     /**
      * Returns a historical pressure coordinate, as per {@link #getPressure(int)},
      * that occurred between this event and the previous event for the given
      * pointer.  Only applies to ACTION_MOVE events.
      *
      * @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}
      *
      * @see #getHistorySize
      * @see #getPressure(int)
      * @see #AXIS_PRESSURE
      */
     public final float getHistoricalPressure(int pointerIndex, int pos) {
         return nativeGetAxisValue(mNativePtr, AXIS_PRESSURE, pointerIndex, pos);
     }

     /**
      * Returns a historical size coordinate, as per {@link #getSize(int)}, that
      * occurred between this event and the previous event for the given pointer.
      * Only applies to ACTION_MOVE events.
      *
      * @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}
      *
      * @see #getHistorySize
      * @see #getSize(int)
      * @see #AXIS_SIZE
      */
     public final float getHistoricalSize(int pointerIndex, int pos) {
         return nativeGetAxisValue(mNativePtr, AXIS_SIZE, pointerIndex, pos);
     }

     /**
      * Returns a historical touch major axis coordinate, as per {@link #getTouchMajor(int)}, that
      * occurred between this event and the previous event for the given pointer.
      * Only applies to ACTION_MOVE events.
      *
      * @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}
      *
      * @see #getHistorySize
      * @see #getTouchMajor(int)
      * @see #AXIS_TOUCH_MAJOR
      */
     public final float getHistoricalTouchMajor(int pointerIndex, int pos) {
         return nativeGetAxisValue(mNativePtr, AXIS_TOUCH_MAJOR, pointerIndex, pos);
     }

     /**
      * Returns a historical touch minor axis coordinate, as per {@link #getTouchMinor(int)}, that
      * occurred between this event and the previous event for the given pointer.
      * Only applies to ACTION_MOVE events.
      *
      * @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}
      *
      * @see #getHistorySize
      * @see #getTouchMinor(int)
      * @see #AXIS_TOUCH_MINOR
      */
     public final float getHistoricalTouchMinor(int pointerIndex, int pos) {
         return nativeGetAxisValue(mNativePtr, AXIS_TOUCH_MINOR, pointerIndex, pos);
     }

     /**
      * Returns a historical tool major axis coordinate, as per {@link #getToolMajor(int)}, that
      * occurred between this event and the previous event for the given pointer.
      * Only applies to ACTION_MOVE events.
      *
      * @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}
      *
      * @see #getHistorySize
      * @see #getToolMajor(int)
      * @see #AXIS_TOOL_MAJOR
      */
     public final float getHistoricalToolMajor(int pointerIndex, int pos) {
         return nativeGetAxisValue(mNativePtr, AXIS_TOOL_MAJOR, pointerIndex, pos);
     }

     /**
      * Returns a historical tool minor axis coordinate, as per {@link #getToolMinor(int)}, that
      * occurred between this event and the previous event for the given pointer.
      * Only applies to ACTION_MOVE events.
      *
      * @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}
      *
      * @see #getHistorySize
      * @see #getToolMinor(int)
      * @see #AXIS_TOOL_MINOR
      */
     public final float getHistoricalToolMinor(int pointerIndex, int pos) {
         return nativeGetAxisValue(mNativePtr, AXIS_TOOL_MINOR, pointerIndex, pos);
     }

     /**
      * Returns a historical orientation coordinate, as per {@link #getOrientation(int)}, that
      * occurred between this event and the previous event for the given pointer.
      * Only applies to ACTION_MOVE events.
      *
      * @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}
      *
      * @see #getHistorySize
      * @see #getOrientation(int)
      * @see #AXIS_ORIENTATION
      */
     public final float getHistoricalOrientation(int pointerIndex, int pos) {
         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);
     }

     /**
      * Populates a {@link PointerCoords} object with historical pointer coordinate data,
      * as per {@link #getPointerCoords}, that occurred between this event and the previous
      * event for the given pointer.
      * Only applies to ACTION_MOVE events.
      *
      * @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}
      * @param outPointerCoords The pointer coordinate object to populate.
      *
      * @see #getHistorySize
      * @see #getPointerCoords
      * @see PointerCoords
      */
     public final void getHistoricalPointerCoords(int pointerIndex, int pos,
             PointerCoords outPointerCoords) {
         nativeGetPointerCoords(mNativePtr, pointerIndex, pos, outPointerCoords);
     }

     /**
      * Returns a bitfield indicating which edges, if any, were touched by this
      * MotionEvent. For touch events, clients can use this to determine if the
      * user's finger was touching the edge of the display.
      *
      * This property is only set for {@link #ACTION_DOWN} events.
      *
      * @see #EDGE_LEFT
      * @see #EDGE_TOP
      * @see #EDGE_RIGHT
      * @see #EDGE_BOTTOM
      */
     public final int getEdgeFlags() {
         return nativeGetEdgeFlags(mNativePtr);
     }

     /**
      * Sets the bitfield indicating which edges, if any, were touched by this
      * MotionEvent.
      *
      * @see #getEdgeFlags()
      */
     public final void setEdgeFlags(int flags) {
         nativeSetEdgeFlags(mNativePtr, flags);
     }

     /**
      * Sets this event's action.
      */
     public final void setAction(int action) {
         final int actionMasked = action & ACTION_MASK;
         if (actionMasked == ACTION_CANCEL) {
             setCanceled(true);
         } else if (actionMasked == ACTION_POINTER_UP) {
             // Do nothing - we don't know what the real intent here is
         } else {
             setCanceled(false);
         }
         nativeSetAction(mNativePtr, action);
     }

     /**
      * Adjust this event's location.
      * @param deltaX Amount to add to the current X coordinate of the event.
      * @param deltaY Amount to add to the current Y coordinate of the event.
      */
     public final void offsetLocation(float deltaX, float deltaY) {
         if (deltaX != 0.0f || deltaY != 0.0f) {
             nativeOffsetLocation(mNativePtr, deltaX, deltaY);
         }
     }

     /**
      * Set this event's location.  Applies {@link #offsetLocation} with a
      * delta from the current location to the given new location.
      *
      * @param x New absolute X location.
      * @param y New absolute Y location.
      */
     public final void setLocation(float x, float y) {
         float oldX = getX();
         float oldY = getY();
         offsetLocation(x - oldX, y - oldY);
     }

     /**
      * Applies a transformation matrix to all of the points in the event.
      *
      * @param matrix The transformation matrix to apply.
      */
     public final void transform(Matrix matrix) {
         if (matrix == null) {
             throw new IllegalArgumentException("matrix must not be null");
         }

         nativeTransform(mNativePtr, matrix);
     }

     /**
      * Transforms all of the points in the event directly instead of modifying the event's
      * internal transform.
      *
      * @param matrix The transformation matrix to apply.
      * @hide
      */
     public void applyTransform(Matrix matrix) {
         if (matrix == null) {
             throw new IllegalArgumentException("matrix must not be null");
         }

         nativeApplyTransform(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} or {@link #ACTION_HOVER_MOVE} events.
      *
      * @param eventTime The time stamp (in ms) for this data.
      * @param x The new X position.
      * @param y The new Y position.
      * @param pressure The new pressure.
      * @param size The new size.
      * @param metaState Meta key state.
      */
     public final void addBatch(long eventTime, float x, float y,
             float pressure, float size, int metaState) {
         synchronized (gSharedTempLock) {
             ensureSharedTempPointerCapacity(1);
             final PointerCoords[] pc = gSharedTempPointerCoords;
             pc[0].clear();
             pc[0].x = x;
             pc[0].y = y;
             pc[0].pressure = pressure;
             pc[0].size = size;

             nativeAddBatch(mNativePtr, eventTime * NS_PER_MS, pc, 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} or {@link #ACTION_HOVER_MOVE} events.
      *
      * @param eventTime The time stamp (in ms) for this data.
      * @param pointerCoords The new pointer coordinates.
      * @param metaState Meta key state.
      */
     public final void addBatch(long eventTime, PointerCoords[] pointerCoords, int metaState) {
         nativeAddBatch(mNativePtr, eventTime * NS_PER_MS, pointerCoords, metaState);
     }

     /**
      * Adds all of the movement samples of the specified event to this one if
      * it is compatible.  To be compatible, the event must have the same device id,
      * source, display id, action, flags, classification, pointer count, pointer properties.
      *
      * Only applies to {@link #ACTION_MOVE} or {@link #ACTION_HOVER_MOVE} events.
      *
      * @param event The event whose movements samples should be added to this one
      * if possible.
      * @return True if batching was performed or false if batching was not possible.
      * @hide
      */
     @UnsupportedAppUsage
     public final boolean addBatch(MotionEvent event) {
         final int action = nativeGetAction(mNativePtr);
         if (action != ACTION_MOVE && action != ACTION_HOVER_MOVE) {
             return false;
         }
         if (action != nativeGetAction(event.mNativePtr)) {
             return false;
         }

         if (nativeGetDeviceId(mNativePtr) != nativeGetDeviceId(event.mNativePtr)
                 || nativeGetSource(mNativePtr) != nativeGetSource(event.mNativePtr)
                 || nativeGetDisplayId(mNativePtr) != nativeGetDisplayId(event.mNativePtr)
                 || nativeGetFlags(mNativePtr) != nativeGetFlags(event.mNativePtr)
                 || nativeGetClassification(mNativePtr)
                         != nativeGetClassification(event.mNativePtr)) {
             return false;
         }

         final int pointerCount = nativeGetPointerCount(mNativePtr);
         if (pointerCount != nativeGetPointerCount(event.mNativePtr)) {
             return false;
         }

         synchronized (gSharedTempLock) {
             ensureSharedTempPointerCapacity(Math.max(pointerCount, 2));
             final PointerProperties[] pp = gSharedTempPointerProperties;
             final PointerCoords[] pc = gSharedTempPointerCoords;

             for (int i = 0; i < pointerCount; i++) {
                 nativeGetPointerProperties(mNativePtr, i, pp[0]);
                 nativeGetPointerProperties(event.mNativePtr, i, pp[1]);
                 if (!pp[0].equals(pp[1])) {
                     return false;
                 }
             }

             final int metaState = nativeGetMetaState(event.mNativePtr);
             final int historySize = nativeGetHistorySize(event.mNativePtr);
             for (int h = 0; h <= historySize; h++) {
                 final int historyPos = (h == historySize ? HISTORY_CURRENT : h);

                 for (int i = 0; i < pointerCount; i++) {
                     nativeGetPointerCoords(event.mNativePtr, i, historyPos, pc[i]);
                 }

                 final long eventTimeNanos = nativeGetEventTimeNanos(event.mNativePtr, historyPos);
                 nativeAddBatch(mNativePtr, eventTimeNanos, pc, metaState);
             }
         }
         return true;
     }

     /**
      * Returns true if all points in the motion event are completely within the specified bounds.
      * @hide
      */
     public final boolean isWithinBoundsNoHistory(float left, float top,
             float right, float bottom) {
         final int pointerCount = nativeGetPointerCount(mNativePtr);
         for (int i = 0; i < pointerCount; i++) {
             final float x = nativeGetAxisValue(mNativePtr, AXIS_X, i, HISTORY_CURRENT);
             final float y = nativeGetAxisValue(mNativePtr, AXIS_Y, i, HISTORY_CURRENT);
             if (x < left || x > right || y < top || y > bottom) {
                 return false;
             }
         }
         return true;
     }

     private static final float clamp(float value, float low, float high) {
         if (value < low) {
             return low;
         } else if (value > high) {
             return high;
         }
         return value;
     }

     /**
      * Returns a new motion events whose points have been clamped to the specified bounds.
      * @hide
      */
     public final MotionEvent clampNoHistory(float left, float top, float right, float bottom) {
         MotionEvent ev = obtain();
         synchronized (gSharedTempLock) {
             final int pointerCount = nativeGetPointerCount(mNativePtr);

             ensureSharedTempPointerCapacity(pointerCount);
             final PointerProperties[] pp = gSharedTempPointerProperties;
             final PointerCoords[] pc = gSharedTempPointerCoords;

             for (int i = 0; i < pointerCount; i++) {
                 nativeGetPointerProperties(mNativePtr, i, pp[i]);
                 nativeGetPointerCoords(mNativePtr, i, HISTORY_CURRENT, pc[i]);
                 pc[i].x = clamp(pc[i].x, left, right);
                 pc[i].y = clamp(pc[i].y, top, bottom);
             }
             ev.initialize(nativeGetDeviceId(mNativePtr), nativeGetSource(mNativePtr),
                     nativeGetDisplayId(mNativePtr),
                     nativeGetAction(mNativePtr), nativeGetFlags(mNativePtr),
                     nativeGetEdgeFlags(mNativePtr), nativeGetMetaState(mNativePtr),
                     nativeGetButtonState(mNativePtr), nativeGetClassification(mNativePtr),
                     nativeGetRawXOffset(mNativePtr), nativeGetRawYOffset(mNativePtr),
                     nativeGetXPrecision(mNativePtr), nativeGetYPrecision(mNativePtr),
                     nativeGetDownTimeNanos(mNativePtr),
                     nativeGetEventTimeNanos(mNativePtr, HISTORY_CURRENT),
                     pointerCount, pp, pc);
             return ev;
         }
     }

     /**
      * Gets an integer where each pointer id present in the event is marked as a bit.
      * @hide
      */
     @UnsupportedAppUsage
     public final int getPointerIdBits() {
         int idBits = 0;
         final int pointerCount = nativeGetPointerCount(mNativePtr);
         for (int i = 0; i < pointerCount; i++) {
             idBits |= 1 << nativeGetPointerId(mNativePtr, i);
         }
         return idBits;
     }

     /**
      * Splits a motion event such that it includes only a subset of pointer IDs.
      * @param idBits the bitset indicating all of the pointer IDs from this motion event that should
      *               be in the new split event. idBits must be a non-empty subset of the pointer IDs
      *               contained in this event.
      * @hide
      */
     // TODO(b/327503168): Pass downTime as a parameter to split.
     @UnsupportedAppUsage
     @NonNull
     public final MotionEvent split(int idBits) {
         if (idBits == 0) {
             throw new IllegalArgumentException(
                     "idBits must contain at least one pointer from this motion event");
         }
         final int currentBits = getPointerIdBits();
         if ((currentBits & idBits) != idBits) {
             throw new IllegalArgumentException(
                     "idBits must be a non-empty subset of the pointer IDs from this MotionEvent, "
                             + "got idBits: "
                             + String.format("0x%x", idBits) + " for " + this);
         }
         MotionEvent event = obtain();
         event.mNativePtr = nativeSplit(event.mNativePtr, this.mNativePtr, idBits);
         return event;
     }

     /**
      * Calculate new cursor position for events from mouse. This is used to split, clamp and inject
      * events.
      *
      * <p>If the source is mouse, it sets cursor position to the centroid of all pointers because
      * InputReader maps multiple fingers on a touchpad to locations around cursor position in screen
      * coordinates so that the mouse cursor is at the centroid of all pointers.
      *
      * <p>If the source is not mouse it sets cursor position to NaN.
      */
     private void updateCursorPosition() {
         if (getSource() != InputDevice.SOURCE_MOUSE) {
             setCursorPosition(INVALID_CURSOR_POSITION, INVALID_CURSOR_POSITION);
             return;
         }

         float x = 0;
         float y = 0;

         final int pointerCount = getPointerCount();
         for (int i = 0; i < pointerCount; ++i) {
             x += getX(i);
             y += getY(i);
         }

         // If pointer count is 0, divisions below yield NaN, which is an acceptable result for this
         // corner case.
         x /= pointerCount;
         y /= pointerCount;
         setCursorPosition(x, y);
     }

     @Override
     public String toString() {
         StringBuilder msg = new StringBuilder();
         msg.append("MotionEvent { action=").append(actionToString(getAction()));
         appendUnless("0", msg, ", actionButton=", buttonStateToString(getActionButton()));

         final int pointerCount = getPointerCount();
         for (int i = 0; i < pointerCount; i++) {
             appendUnless(i, msg, ", id[" + i + "]=", getPointerId(i));
             float x = getX(i);
             float y = getY(i);
             if (!DEBUG_CONCISE_TOSTRING || x != 0f || y != 0f) {
                 msg.append(", x[").append(i).append("]=").append(x);
                 msg.append(", y[").append(i).append("]=").append(y);
             }
             appendUnless(TOOL_TYPE_SYMBOLIC_NAMES.get(TOOL_TYPE_FINGER),
                     msg, ", toolType[" + i + "]=", toolTypeToString(getToolType(i)));
         }

         appendUnless("0", msg, ", buttonState=", MotionEvent.buttonStateToString(getButtonState()));
         appendUnless(classificationToString(CLASSIFICATION_NONE), msg, ", classification=",
                 classificationToString(getClassification()));
         appendUnless("0", msg, ", metaState=", KeyEvent.metaStateToString(getMetaState()));
         appendUnless("0", msg, ", flags=0x", Integer.toHexString(getFlags()));
         appendUnless("0", msg, ", edgeFlags=0x", Integer.toHexString(getEdgeFlags()));
         appendUnless(1, msg, ", pointerCount=", pointerCount);
         appendUnless(0, msg, ", historySize=", getHistorySize());
         msg.append(", eventTime=").append(getEventTime());
         if (!DEBUG_CONCISE_TOSTRING) {
             msg.append(", downTime=").append(getDownTime());
             msg.append(", deviceId=").append(getDeviceId());
             msg.append(", source=0x").append(Integer.toHexString(getSource()));
             msg.append(", displayId=").append(getDisplayId());
             msg.append(", eventId=").append(getId());
         }
         msg.append(" }");
         return msg.toString();
     }

     private static <T> void appendUnless(T defValue, StringBuilder sb, String key, T value) {
         if (DEBUG_CONCISE_TOSTRING && Objects.equals(defValue, value)) return;
         sb.append(key).append(value);
     }

     /**
      * Returns a string that represents the symbolic name of the specified unmasked action
      * such as "ACTION_DOWN", "ACTION_POINTER_DOWN(3)" or an equivalent numeric constant
      * such as "35" if unknown.
      *
      * @param action The unmasked action.
      * @return The symbolic name of the specified action.
      * @see #getAction()
      */
     public static String actionToString(int action) {
         switch (action) {
             case ACTION_DOWN:
                 return "ACTION_DOWN";
             case ACTION_UP:
                 return "ACTION_UP";
             case ACTION_CANCEL:
                 return "ACTION_CANCEL";
             case ACTION_OUTSIDE:
                 return "ACTION_OUTSIDE";
             case ACTION_MOVE:
                 return "ACTION_MOVE";
             case ACTION_HOVER_MOVE:
                 return "ACTION_HOVER_MOVE";
             case ACTION_SCROLL:
                 return "ACTION_SCROLL";
             case ACTION_HOVER_ENTER:
                 return "ACTION_HOVER_ENTER";
             case ACTION_HOVER_EXIT:
                 return "ACTION_HOVER_EXIT";
             case ACTION_BUTTON_PRESS:
                 return "ACTION_BUTTON_PRESS";
             case ACTION_BUTTON_RELEASE:
                 return "ACTION_BUTTON_RELEASE";
         }
         int index = (action & ACTION_POINTER_INDEX_MASK) >> ACTION_POINTER_INDEX_SHIFT;
         switch (action & ACTION_MASK) {
             case ACTION_POINTER_DOWN:
                 return "ACTION_POINTER_DOWN(" + index + ")";
             case ACTION_POINTER_UP:
                 return "ACTION_POINTER_UP(" + index + ")";
             default:
                 return Integer.toString(action);
         }
     }

     /**
      * Returns a string that represents the symbolic name of the specified axis
      * such as "AXIS_X" or an equivalent numeric constant such as "42" if unknown.
      *
      * @param axis The axis.
      * @return The symbolic name of the specified axis.
      */
     public static String axisToString(int axis) {
         String symbolicName = nativeAxisToString(axis);
         return symbolicName != null ? LABEL_PREFIX + symbolicName : Integer.toString(axis);
     }

     /**
      * Gets an axis by its symbolic name such as "AXIS_X" or an
      * equivalent numeric constant such as "42".
      *
      * @param symbolicName The symbolic name of the axis.
      * @return The axis or -1 if not found.
      * @see KeyEvent#keyCodeToString(int)
      */
     public static int axisFromString(String symbolicName) {
         if (symbolicName.startsWith(LABEL_PREFIX)) {
             symbolicName = symbolicName.substring(LABEL_PREFIX.length());
             int axis = nativeAxisFromString(symbolicName);
             if (axis >= 0) {
                 return axis;
             }
         }
         try {
             return Integer.parseInt(symbolicName, 10);
         } catch (NumberFormatException ex) {
             return -1;
         }
     }

     /**
      * Returns a string that represents the symbolic name of the specified combined
      * button state flags such as "0", "BUTTON_PRIMARY",
      * "BUTTON_PRIMARY|BUTTON_SECONDARY" or an equivalent numeric constant such as "0x10000000"
      * if unknown.
      *
      * @param buttonState The button state.
      * @return The symbolic name of the specified combined button state flags.
      * @hide
      */
     public static String buttonStateToString(int buttonState) {
         if (buttonState == 0) {
             return "0";
         }
         StringBuilder result = null;
         int i = 0;
         while (buttonState != 0) {
             final boolean isSet = (buttonState & 1) != 0;
             buttonState >>>= 1; // unsigned shift!
             if (isSet) {
                 final String name = BUTTON_SYMBOLIC_NAMES[i];
                 if (result == null) {
                     if (buttonState == 0) {
                         return name;
                     }
                     result = new StringBuilder(name);
                 } else {
                     result.append('|');
                     result.append(name);
                 }
             }
             i += 1;
         }
         return result.toString();
     }

     /**
      * Returns a string that represents the symbolic name of the specified classification.
      *
      * @param classification The classification type.
      * @return The symbolic name of this classification.
      * @hide
      */
     public static String classificationToString(@Classification int classification) {
         switch (classification) {
             case CLASSIFICATION_NONE:
                 return "NONE";
             case CLASSIFICATION_AMBIGUOUS_GESTURE:
                 return "AMBIGUOUS_GESTURE";
             case CLASSIFICATION_DEEP_PRESS:
                 return "DEEP_PRESS";
             case CLASSIFICATION_TWO_FINGER_SWIPE:
                 return "TWO_FINGER_SWIPE";
             case CLASSIFICATION_MULTI_FINGER_SWIPE:
                 return "MULTI_FINGER_SWIPE";
         }
         return "UNKNOWN";
     }

     /**
      * Returns a string that represents the symbolic name of the specified tool type
      * such as "TOOL_TYPE_FINGER" or an equivalent numeric constant such as "42" if unknown.
      *
      * @param toolType The tool type.
      * @return The symbolic name of the specified tool type.
      * @hide
      */
     public static String toolTypeToString(@ToolType int toolType) {
         String symbolicName = TOOL_TYPE_SYMBOLIC_NAMES.get(toolType);
         return symbolicName != null ? symbolicName : Integer.toString(toolType);
     }

     /**
      * Checks if a mouse or stylus button (or combination of buttons) is pressed.
      * @param button Button (or combination of buttons).
      * @return True if specified buttons are pressed.
      *
      * @see #BUTTON_PRIMARY
      * @see #BUTTON_SECONDARY
      * @see #BUTTON_TERTIARY
      * @see #BUTTON_FORWARD
      * @see #BUTTON_BACK
      * @see #BUTTON_STYLUS_PRIMARY
      * @see #BUTTON_STYLUS_SECONDARY
      */
     public final boolean isButtonPressed(int button) {
         if (button == 0) {
             return false;
         }
         return (getButtonState() & button) == button;
     }

     /**
      * Gets the rotation value of the transform for this MotionEvent.
      *
      * This MotionEvent's rotation can be changed by passing a rotation matrix to
      * {@link #transform(Matrix)} to change the coordinate space of this event.
      *
      * @return the rotation value, or -1 if unknown or invalid.
      * @see Surface.Rotation
      * @see #createRotateMatrix(int, int, int)
      *
      * @hide
      */
     public @Surface.Rotation int getSurfaceRotation() {
         return nativeGetSurfaceRotation(mNativePtr);
     }

     /**
      * Gets a rotation matrix that (when applied to a MotionEvent) will rotate that motion event
      * such that the result coordinates end up in the same physical location on a frame whose
      * coordinates are rotated by `rotation`.
      *
      * For example, rotating (0,0) by 90 degrees will move a point from the physical top-left to
      * the bottom-left of the 90-degree-rotated frame.
      *
      * @param rotation the surface rotation of the output matrix
      * @param rotatedFrameWidth the width of the rotated frame
      * @param rotatedFrameHeight the height of the rotated frame
      *
      * @see #transform(Matrix)
      * @see #getSurfaceRotation()
      * @hide
      */
     public static Matrix createRotateMatrix(
             @Surface.Rotation int rotation, int rotatedFrameWidth, int rotatedFrameHeight) {
         if (rotation == Surface.ROTATION_0) {
             return new Matrix(Matrix.IDENTITY_MATRIX);
         }
         // values is row-major
         float[] values = null;
         if (rotation == Surface.ROTATION_90) {
             values = new float[]{0, 1, 0,
                     -1, 0, rotatedFrameHeight,
                     0, 0, 1};
         } else if (rotation == Surface.ROTATION_180) {
             values = new float[]{-1, 0, rotatedFrameWidth,
                     0, -1, rotatedFrameHeight,
                     0, 0, 1};
         } else if (rotation == Surface.ROTATION_270) {
             values = new float[]{0, -1, rotatedFrameWidth,
                     1, 0, 0,
                     0, 0, 1};
         }
         Matrix toOrient = new Matrix();
         toOrient.setValues(values);
         return toOrient;
     }

     public static final @android.annotation.NonNull Parcelable.Creator<MotionEvent> CREATOR
             = new Parcelable.Creator<MotionEvent>() {
         public MotionEvent createFromParcel(Parcel in) {
             in.readInt(); // skip token, we already know this is a MotionEvent
             return MotionEvent.createFromParcelBody(in);
         }

         public MotionEvent[] newArray(int size) {
             return new MotionEvent[size];
         }
     };

     /** @hide */
     public static MotionEvent createFromParcelBody(Parcel in) {
         MotionEvent ev = obtain();
         ev.mNativePtr = nativeReadFromParcel(ev.mNativePtr, in);
         return ev;
     }

     /** @hide */
     @Override
     public final void cancel() {
         setCanceled(true);
         setAction(ACTION_CANCEL);
     }

     public void writeToParcel(Parcel out, int flags) {
         out.writeInt(PARCEL_TOKEN_MOTION_EVENT);
         nativeWriteToParcel(mNativePtr, out);
     }

     /**
      * Get the x coordinate of the location where the pointer should be dispatched.
      *
      * This is required because a mouse event, such as from a touchpad, may contain multiple
      * pointers that should all be dispatched to the cursor position.
      * @hide
      */
     public float getXDispatchLocation(int pointerIndex) {
         if (isFromSource(InputDevice.SOURCE_MOUSE)) {
             final float xCursorPosition = getXCursorPosition();
             if (xCursorPosition != INVALID_CURSOR_POSITION) {
                 return xCursorPosition;
             }
         }
         return getX(pointerIndex);
     }

     /**
      * Get the y coordinate of the location where the pointer should be dispatched.
      *
      * This is required because a mouse event, such as from a touchpad, may contain multiple
      * pointers that should all be dispatched to the cursor position.
      * @hide
      */
     public float getYDispatchLocation(int pointerIndex) {
         if (isFromSource(InputDevice.SOURCE_MOUSE)) {
             final float yCursorPosition = getYCursorPosition();
             if (yCursorPosition != INVALID_CURSOR_POSITION) {
                 return yCursorPosition;
             }
         }
         return getY(pointerIndex);
     }

     /**
      * Transfer object for pointer coordinates.
      *
      * Objects of this type can be used to specify the pointer coordinates when
      * creating new {@link MotionEvent} objects and to query pointer coordinates
      * in bulk.
      *
      * Refer to {@link InputDevice} for information about how different kinds of
      * input devices and sources represent pointer coordinates.
      */
     public static final class PointerCoords {
         private static final int INITIAL_PACKED_AXIS_VALUES = 8;
         @UnsupportedAppUsage
         private long mPackedAxisBits;
         @UnsupportedAppUsage
         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);
         }

         /** @hide */
         @UnsupportedAppUsage
         public static PointerCoords[] createArray(int size) {
             PointerCoords[] array = new PointerCoords[size];
             for (int i = 0; i < size; i++) {
                 array[i] = new PointerCoords();
             }
             return array;
         }

         /**
          * The X component of the pointer movement.
          *
          * @see MotionEvent#AXIS_X
          */
         public float x;

         /**
          * The Y component of the pointer movement.
          *
          * @see MotionEvent#AXIS_Y
          */
         public float y;

         /**
          * 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),
          * although values higher than 1 may be generated depending on the calibration of
          * the input device.
          *
          * @see MotionEvent#AXIS_PRESSURE
          */
         public float pressure;

         /**
          * 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;

         /**
          * 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 MotionEvent#AXIS_TOOL_MAJOR
          */
         public float toolMajor;

         /**
          * The length of the minor 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 MotionEvent#AXIS_TOOL_MINOR
          */
         public float toolMinor;

         /**
          * The orientation of the touch area and tool area in radians clockwise from vertical.
          * An angle of 0 radians 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 MotionEvent#AXIS_ORIENTATION
          */
         public float orientation;

         /**
          * The movement of x position of a motion event.
          *
          * @see MotionEvent#AXIS_RELATIVE_X
          * @hide
          */
         public float relativeX;

         /**
          * The movement of y position of a motion event.
          *
          * @see MotionEvent#AXIS_RELATIVE_Y
          * @hide
          */
         public float relativeY;

         /**
          * Whether these coordinate data were generated by resampling.
          *
          * @hide
          */
         public boolean isResampled;

         /**
          * Returns true if these pointer coordinates were generated by resampling, rather than from
          * an actual input event from the device at this time.
          * <p>
          * Resampling extrapolates or interpolates touch coordinates reported by the input device to
          * better align them with the refresh rate of the display, resulting in smoother movements,
          * in particular for scrolling. Resampled coordinates are always added to batches, so a
          * motion event will always contain at least one sample that is an original event from the
          * input device (i.e. for which this method will return {@code false}).
          * </p><p>
          * Resampling does not occur if unbuffered dispatch has been requested, or if it has been
          * disabled by the manufacturer (for example, on hardware that already synchronizes its
          * touch events and display frames).
          * </p>
          * @see android.view.View#requestUnbufferedDispatch(int)
          * @see android.view.View#requestUnbufferedDispatch(MotionEvent)
          */
         @FlaggedApi(Flags.FLAG_POINTER_COORDS_IS_RESAMPLED_API)
         public boolean isResampled() {
             return isResampled;
         }

         /**
          * 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;
             relativeX = 0;
             relativeY = 0;
             isResampled = false;
         }

         /**
          * Copies the contents of another pointer coords object.
          *
          * @param other The pointer coords object to copy.
          */
         public void copyFrom(PointerCoords other) {
             final long bits = other.mPackedAxisBits;
             mPackedAxisBits = bits;
             if (bits != 0) {
                 final float[] otherValues = other.mPackedAxisValues;
                 final int count = Long.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;
             relativeX = other.relativeX;
             relativeY = other.relativeY;
             isResampled = other.isResampled;
         }

         /**
          * 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;
                 case AXIS_RELATIVE_X:
                     return relativeX;
                 case AXIS_RELATIVE_Y:
                     return relativeY;
                 default: {
                     if (axis < 0 || axis > 63) {
                         throw new IllegalArgumentException("Axis out of range.");
                     }
                     final long bits = mPackedAxisBits;
                     final long axisBit = 0x8000000000000000L >>> axis;
                     if ((bits & axisBit) == 0) {
                         return 0;
                     }
                     final int index = Long.bitCount(bits & ~(0xFFFFFFFFFFFFFFFFL >>> axis));
                     return mPackedAxisValues[index];
                 }
             }
         }

         /**
          * 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;
                 case AXIS_RELATIVE_X:
                     relativeX = value;
                     break;
                 case AXIS_RELATIVE_Y:
                     relativeY = value;
                     break;
                 default: {
                     if (axis < 0 || axis > 63) {
                         throw new IllegalArgumentException("Axis out of range.");
                     }
                     final long bits = mPackedAxisBits;
                     final long axisBit = 0x8000000000000000L >>> axis;
                     final int index = Long.bitCount(bits & ~(0xFFFFFFFFFFFFFFFFL >>> axis));
                     float[] values = mPackedAxisValues;
                     if ((bits & axisBit) == 0) {
                         if (values == null) {
                             values = new float[INITIAL_PACKED_AXIS_VALUES];
                             mPackedAxisValues = values;
                         } else {
                             final int count = Long.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;
                 }
             }
         }
     }

     /**
      * Transfer object for pointer properties.
      *
      * Objects of this type can be used to specify the pointer id and tool type
      * when creating new {@link MotionEvent} objects and to query pointer properties in bulk.
      */
     public static final class PointerProperties {
         /**
          * Creates a pointer properties object with an invalid pointer id.
          */
         public PointerProperties() {
             clear();
         }

         /**
          * Creates a pointer properties object as a copy of the contents of
          * another pointer properties object.
          * @param other
          */
         public PointerProperties(PointerProperties other) {
             copyFrom(other);
         }

         /** @hide */
         @UnsupportedAppUsage
         public static PointerProperties[] createArray(int size) {
             PointerProperties[] array = new PointerProperties[size];
             for (int i = 0; i < size; i++) {
                 array[i] = new PointerProperties();
             }
             return array;
         }

         /**
          * The pointer id.
          * Initially set to {@link #INVALID_POINTER_ID} (-1).
          *
          * @see MotionEvent#getPointerId(int)
          */
         public int id;

         /**
          * The pointer tool type.
          * Initially set to 0.
          *
          * @see MotionEvent#getToolType(int)
          */
         public @ToolType int toolType;

         /**
          * Resets the pointer properties to their initial values.
          */
         public void clear() {
             id = INVALID_POINTER_ID;
             toolType = TOOL_TYPE_UNKNOWN;
         }

         /**
          * Copies the contents of another pointer properties object.
          *
          * @param other The pointer properties object to copy.
          */
         public void copyFrom(PointerProperties other) {
             id = other.id;
             toolType = other.toolType;
         }

         @Override
         public boolean equals(@Nullable Object other) {
             if (other instanceof PointerProperties) {
                 return equals((PointerProperties)other);
             }
             return false;
         }

         private boolean equals(PointerProperties other) {
             return other != null && id == other.id && toolType == other.toolType;
         }

         @Override
         public int hashCode() {
             return id | (toolType << 8);
         }
     }
 }