diff --git a/api/current.txt b/api/current.txt
index 12fa844..86703ba 100644
--- a/api/current.txt
+++ b/api/current.txt
@@ -20158,6 +20158,7 @@
     field public static final int SOURCE_JOYSTICK = 16777232; // 0x1000010
     field public static final int SOURCE_KEYBOARD = 257; // 0x101
     field public static final int SOURCE_MOUSE = 8194; // 0x2002
+    field public static final int SOURCE_STYLUS = 16386; // 0x4002
     field public static final int SOURCE_TOUCHPAD = 1048584; // 0x100008
     field public static final int SOURCE_TOUCHSCREEN = 4098; // 0x1002
     field public static final int SOURCE_TRACKBALL = 65540; // 0x10004
@@ -20690,6 +20691,7 @@
     method public final int getActionMasked();
     method public final float getAxisValue(int);
     method public final float getAxisValue(int, int);
+    method public final int getButtonState();
     method public final int getDeviceId();
     method public final long getDownTime();
     method public final int getEdgeFlags();
@@ -20724,6 +20726,7 @@
     method public final void getPointerCoords(int, android.view.MotionEvent.PointerCoords);
     method public final int getPointerCount();
     method public final int getPointerId(int);
+    method public final void getPointerProperties(int, android.view.MotionEvent.PointerProperties);
     method public final float getPressure();
     method public final float getPressure(int);
     method public final float getRawX();
@@ -20735,6 +20738,7 @@
     method public final float getToolMajor(int);
     method public final float getToolMinor();
     method public final float getToolMinor(int);
+    method public final int getToolType(int);
     method public final float getTouchMajor();
     method public final float getTouchMajor(int);
     method public final float getTouchMinor();
@@ -20745,7 +20749,8 @@
     method public final float getY();
     method public final float getY(int);
     method public final float getYPrecision();
-    method public static android.view.MotionEvent obtain(long, long, int, int, int[], android.view.MotionEvent.PointerCoords[], int, float, float, int, int, int, int);
+    method public static android.view.MotionEvent obtain(long, long, int, int, android.view.MotionEvent.PointerProperties[], android.view.MotionEvent.PointerCoords[], int, int, float, float, int, int, int, int);
+    method public static deprecated android.view.MotionEvent obtain(long, long, int, int, int[], android.view.MotionEvent.PointerCoords[], int, float, float, int, int, int, int);
     method public static android.view.MotionEvent obtain(long, long, int, float, float, float, float, int, float, float, int, int);
     method public static deprecated android.view.MotionEvent obtain(long, long, int, int, float, float, float, float, int, float, float, int, int);
     method public static android.view.MotionEvent obtain(long, long, int, float, float, int);
@@ -20782,6 +20787,7 @@
     field public static final int ACTION_SCROLL = 8; // 0x8
     field public static final int ACTION_UP = 1; // 0x1
     field public static final int AXIS_BRAKE = 23; // 0x17
+    field public static final int AXIS_DISTANCE = 24; // 0x18
     field public static final int AXIS_GAS = 22; // 0x16
     field public static final int AXIS_GENERIC_1 = 32; // 0x20
     field public static final int AXIS_GENERIC_10 = 41; // 0x29
@@ -20821,12 +20827,25 @@
     field public static final int AXIS_X = 0; // 0x0
     field public static final int AXIS_Y = 1; // 0x1
     field public static final int AXIS_Z = 11; // 0xb
+    field public static final int BUTTON_BACK = 8; // 0x8
+    field public static final int BUTTON_ERASER = 32; // 0x20
+    field public static final int BUTTON_FORWARD = 16; // 0x10
+    field public static final int BUTTON_PRIMARY = 1; // 0x1
+    field public static final int BUTTON_SECONDARY = 2; // 0x2
+    field public static final int BUTTON_TERTIARY = 4; // 0x4
     field public static final android.os.Parcelable.Creator CREATOR;
     field public static final int EDGE_BOTTOM = 2; // 0x2
     field public static final int EDGE_LEFT = 4; // 0x4
     field public static final int EDGE_RIGHT = 8; // 0x8
     field public static final int EDGE_TOP = 1; // 0x1
     field public static final int FLAG_WINDOW_IS_OBSCURED = 1; // 0x1
+    field public static final int INVALID_POINTER_ID = -1; // 0xffffffff
+    field public static final int TOOL_TYPE_FINGER = 1; // 0x1
+    field public static final int TOOL_TYPE_INDIRECT_FINGER = 4; // 0x4
+    field public static final int TOOL_TYPE_INDIRECT_STYLUS = 5; // 0x5
+    field public static final int TOOL_TYPE_MOUSE = 3; // 0x3
+    field public static final int TOOL_TYPE_STYLUS = 2; // 0x2
+    field public static final int TOOL_TYPE_UNKNOWN = 0; // 0x0
   }
 
   public static final class MotionEvent.PointerCoords {
@@ -20847,6 +20866,15 @@
     field public float y;
   }
 
+  public static final class MotionEvent.PointerProperties {
+    ctor public MotionEvent.PointerProperties();
+    ctor public MotionEvent.PointerProperties(android.view.MotionEvent.PointerProperties);
+    method public void clear();
+    method public void copyFrom(android.view.MotionEvent.PointerProperties);
+    field public int id;
+    field public int toolType;
+  }
+
   public abstract class OrientationEventListener {
     ctor public OrientationEventListener(android.content.Context);
     ctor public OrientationEventListener(android.content.Context, int);
diff --git a/core/java/android/inputmethodservice/SoftInputWindow.java b/core/java/android/inputmethodservice/SoftInputWindow.java
index 343242e..7159260 100644
--- a/core/java/android/inputmethodservice/SoftInputWindow.java
+++ b/core/java/android/inputmethodservice/SoftInputWindow.java
@@ -73,8 +73,17 @@
     @Override
     public boolean dispatchTouchEvent(MotionEvent ev) {
         getWindow().getDecorView().getHitRect(mBounds);
-        final MotionEvent event = clipMotionEvent(ev, mBounds);
-        return super.dispatchTouchEvent(event);
+
+        if (ev.isWithinBoundsNoHistory(mBounds.left, mBounds.top,
+                mBounds.right - 1, mBounds.bottom - 1)) {
+            return super.dispatchTouchEvent(ev);
+        } else {
+            MotionEvent temp = ev.clampNoHistory(mBounds.left, mBounds.top,
+                    mBounds.right - 1, mBounds.bottom - 1);
+            boolean handled = super.dispatchTouchEvent(temp);
+            temp.recycle();
+            return handled;
+        }
     }
 
     /**
@@ -163,48 +172,4 @@
                 WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE |
                 WindowManager.LayoutParams.FLAG_DIM_BEHIND);
     }
-
-    private static MotionEvent clipMotionEvent(MotionEvent me, Rect bounds) {
-        final int pointerCount = me.getPointerCount();
-        boolean shouldClip = false;
-        for (int pointerIndex = 0; pointerIndex < pointerCount; pointerIndex++) {
-            final int x = (int)me.getX(pointerIndex);
-            final int y = (int)me.getY(pointerIndex);
-            if (!bounds.contains(x, y)) {
-                shouldClip = true;
-                break;
-            }
-        }
-        if (!shouldClip)
-            return me;
-
-        if (pointerCount == 1) {
-            final int x = (int)me.getX();
-            final int y = (int)me.getY();
-            me.setLocation(
-                    Math.max(bounds.left, Math.min(x, bounds.right - 1)),
-                    Math.max(bounds.top, Math.min(y, bounds.bottom - 1)));
-            return me;
-        }
-
-        final int[] pointerIds = new int[pointerCount];
-        final MotionEvent.PointerCoords[] pointerCoords =
-            new MotionEvent.PointerCoords[pointerCount];
-        for (int pointerIndex = 0; pointerIndex < pointerCount; pointerIndex++) {
-            pointerIds[pointerIndex] = me.getPointerId(pointerIndex);
-            final MotionEvent.PointerCoords coords = new MotionEvent.PointerCoords();
-            me.getPointerCoords(pointerIndex, coords);
-            pointerCoords[pointerIndex] = coords;
-            final int x = (int)coords.x;
-            final int y = (int)coords.y;
-            if (!bounds.contains(x, y)) {
-                coords.x = Math.max(bounds.left, Math.min(x, bounds.right - 1));
-                coords.y = Math.max(bounds.top, Math.min(y, bounds.bottom - 1));
-            }
-        }
-        return MotionEvent.obtain(
-                me.getDownTime(), me.getEventTime(), me.getAction(), pointerCount, pointerIds,
-                pointerCoords, me.getMetaState(), me.getXPrecision(), me.getYPrecision(),
-                me.getDeviceId(), me.getEdgeFlags(), me.getSource(), me.getFlags());
-    }
 }
diff --git a/core/java/android/view/InputDevice.java b/core/java/android/view/InputDevice.java
index 8cb68f9..bfc7c31 100755
--- a/core/java/android/view/InputDevice.java
+++ b/core/java/android/view/InputDevice.java
@@ -153,7 +153,14 @@
      * @see #SOURCE_CLASS_POINTER
      */
     public static final int SOURCE_MOUSE = 0x00002000 | SOURCE_CLASS_POINTER;
-    
+
+    /**
+     * The input source is a stylus pointing device.
+     *
+     * @see #SOURCE_CLASS_POINTER
+     */
+    public static final int SOURCE_STYLUS = 0x00004000 | SOURCE_CLASS_POINTER;
+
     /**
      * The input source is a trackball.
      * 
@@ -585,6 +592,7 @@
         appendSourceDescriptionIfApplicable(description, SOURCE_DPAD, "dpad");
         appendSourceDescriptionIfApplicable(description, SOURCE_TOUCHSCREEN, "touchscreen");
         appendSourceDescriptionIfApplicable(description, SOURCE_MOUSE, "mouse");
+        appendSourceDescriptionIfApplicable(description, SOURCE_STYLUS, "stylus");
         appendSourceDescriptionIfApplicable(description, SOURCE_TRACKBALL, "trackball");
         appendSourceDescriptionIfApplicable(description, SOURCE_TOUCHPAD, "touchpad");
         appendSourceDescriptionIfApplicable(description, SOURCE_JOYSTICK, "joystick");
diff --git a/core/java/android/view/KeyEvent.java b/core/java/android/view/KeyEvent.java
index 13d8809..5dbda90 100755
--- a/core/java/android/view/KeyEvent.java
+++ b/core/java/android/view/KeyEvent.java
@@ -2672,15 +2672,22 @@
 
     @Override
     public String toString() {
-        return "KeyEvent{action=" + actionToString(mAction)
-                + " keycode=" + keyCodeToString(mKeyCode)
-                + " scancode=" + mScanCode
-                + " metaState=" + metaStateToString(mMetaState)
-                + " flags=0x" + Integer.toHexString(mFlags)
-                + " repeat=" + mRepeatCount
-                + " device=" + mDeviceId
-                + " source=0x" + Integer.toHexString(mSource)
-                + "}";
+        StringBuilder msg = new StringBuilder();
+        msg.append("KeyEvent { action=").append(actionToString(mAction));
+        msg.append(", keyCode=").append(keyCodeToString(mKeyCode));
+        msg.append(", scanCode=").append(mScanCode);
+        if (mCharacters != null) {
+            msg.append(", characters=\"").append(mCharacters).append("\"");
+        }
+        msg.append(", metaState=").append(metaStateToString(mMetaState));
+        msg.append(", flags=0x").append(Integer.toHexString(mFlags));
+        msg.append(", repeatCount=").append(mRepeatCount);
+        msg.append(", eventTime=").append(mEventTime);
+        msg.append(", downTime=").append(mDownTime);
+        msg.append(", deviceId=").append(mDeviceId);
+        msg.append(", source=0x").append(Integer.toHexString(mSource));
+        msg.append(" }");
+        return msg.toString();
     }
 
     /**
diff --git a/core/java/android/view/MotionEvent.java b/core/java/android/view/MotionEvent.java
index 7611b08..82fd581 100644
--- a/core/java/android/view/MotionEvent.java
+++ b/core/java/android/view/MotionEvent.java
@@ -23,10 +23,95 @@
 import android.util.SparseArray;
 
 /**
- * Object used to report movement (mouse, pen, finger, trackball) events.  This
- * class may hold either absolute or relative movements, depending on what
- * it is being used for.
+ * 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
@@ -60,80 +145,64 @@
  * 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>
- * Motion events always report movements for all pointers at once.  The number
- * of pointers only ever changes by one as individual pointers go up and down,
- * except when the gesture is canceled.
- * </p><p>
- * The order in which individual pointers appear within a motion event can change
- * from one event to the next. Use the {@link #getPointerId(int)} method to obtain a
- * pointer id to track pointers across 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>
- * 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><p>
- * In general, the framework cannot guarantee that the motion events it delivers
- * to a view always constitute a complete motion sequences since some events may be dropped
- * or modified by containing views before they are delivered.  The view implementation
- * should 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><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 long NS_PER_MS = 1000000;
     private static final boolean TRACK_RECYCLED_LOCATION = 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 #getAction}: A pressed gesture has started, the
+     * 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 #getAction}: A pressed gesture has finished, the
+     * 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 #getAction}: A change has happened during a
+     * 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.
@@ -141,33 +210,43 @@
     public static final int ACTION_MOVE             = 2;
     
     /**
-     * Constant for {@link #getAction}: The current gesture has been aborted.
+     * 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 #getAction}: A movement has happened outside of the
+     * 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.
      */
     public static final int ACTION_OUTSIDE          = 4;
 
     /**
-     * A non-primary pointer has gone down.  The bits in
-     * {@link #ACTION_POINTER_ID_MASK} indicate which pointer changed.
+     * 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;
     
     /**
-     * A non-primary pointer has gone up.  The bits in
-     * {@link #ACTION_POINTER_ID_MASK} indicate which pointer changed.
+     * 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 #getAction}: A change happened but the pointer
+     * 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.
@@ -182,14 +261,14 @@
     public static final int ACTION_HOVER_MOVE       = 7;
 
     /**
-     * Constant for {@link #getAction}: The motion event contains relative
+     * 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></p>
+     * <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><p>
      * This action is not a touch event so it is delivered to
      * {@link View#onGenericMotionEvent(MotionEvent)} rather than
      * {@link View#onTouchEvent(MotionEvent)}.
@@ -198,7 +277,7 @@
     public static final int ACTION_SCROLL           = 8;
 
     /**
-     * Constant for {@link #getAction}: The pointer is not down but has entered the
+     * 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.
@@ -211,7 +290,7 @@
     public static final int ACTION_HOVER_ENTER      = 9;
 
     /**
-     * Constant for {@link #getAction}: The pointer is not down but has exited the
+     * 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.
@@ -230,15 +309,19 @@
      * 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}.
@@ -339,7 +422,7 @@
     public static final int EDGE_RIGHT = 0x00000008;
 
     /**
-     * Constant used to identify the X axis of a motion event.
+     * 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
@@ -364,7 +447,7 @@
     public static final int AXIS_X = 0;
 
     /**
-     * Constant used to identify the Y axis of a motion event.
+     * 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
@@ -389,7 +472,7 @@
     public static final int AXIS_Y = 1;
 
     /**
-     * Constant used to identify the Pressure axis of a motion event.
+     * 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
@@ -411,7 +494,7 @@
     public static final int AXIS_PRESSURE = 2;
 
     /**
-     * Constant used to identify the Size axis of a motion event.
+     * 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
@@ -431,7 +514,7 @@
     public static final int AXIS_SIZE = 3;
 
     /**
-     * Constant used to identify the TouchMajor axis of a motion event.
+     * 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
@@ -452,7 +535,7 @@
     public static final int AXIS_TOUCH_MAJOR = 4;
 
     /**
-     * Constant used to identify the TouchMinor axis of a motion event.
+     * 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
@@ -475,7 +558,7 @@
     public static final int AXIS_TOUCH_MINOR = 5;
 
     /**
-     * Constant used to identify the ToolMajor axis of a motion event.
+     * 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
@@ -500,7 +583,7 @@
     public static final int AXIS_TOOL_MAJOR = 6;
 
     /**
-     * Constant used to identify the ToolMinor axis of a motion event.
+     * 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
@@ -525,7 +608,7 @@
     public static final int AXIS_TOOL_MINOR = 7;
 
     /**
-     * Constant used to identify the Orientation axis of a motion event.
+     * Axis constant: Orientation axis of a motion event.
      * <p>
      * <ul>
      * <li>For a touch screen or touch pad, reports the orientation of the finger
@@ -547,7 +630,7 @@
     public static final int AXIS_ORIENTATION = 8;
 
     /**
-     * Constant used to identify the Vertical Scroll axis of a motion event.
+     * Axis constant: Vertical Scroll axis of a motion event.
      * <p>
      * <ul>
      * <li>For a mouse, reports the relative movement of the vertical scroll wheel.
@@ -565,7 +648,7 @@
     public static final int AXIS_VSCROLL = 9;
 
     /**
-     * Constant used to identify the Horizontal Scroll axis of a motion event.
+     * Axis constant: Horizontal Scroll axis of a motion event.
      * <p>
      * <ul>
      * <li>For a mouse, reports the relative movement of the horizontal scroll wheel.
@@ -583,7 +666,7 @@
     public static final int AXIS_HSCROLL = 10;
 
     /**
-     * Constant used to identify the Z axis of a motion event.
+     * Axis constant: Z axis of a motion event.
      * <p>
      * <ul>
      * <li>For a joystick, reports the absolute Z position of the joystick.
@@ -601,7 +684,7 @@
     public static final int AXIS_Z = 11;
 
     /**
-     * Constant used to identify the X Rotation axis of a motion event.
+     * Axis constant: X Rotation axis of a motion event.
      * <p>
      * <ul>
      * <li>For a joystick, reports the absolute rotation angle about the X axis.
@@ -617,7 +700,7 @@
     public static final int AXIS_RX = 12;
 
     /**
-     * Constant used to identify the Y Rotation axis of a motion event.
+     * Axis constant: Y Rotation axis of a motion event.
      * <p>
      * <ul>
      * <li>For a joystick, reports the absolute rotation angle about the Y axis.
@@ -633,7 +716,7 @@
     public static final int AXIS_RY = 13;
 
     /**
-     * Constant used to identify the Z Rotation axis of a motion event.
+     * Axis constant: Z Rotation axis of a motion event.
      * <p>
      * <ul>
      * <li>For a joystick, reports the absolute rotation angle about the Z axis.
@@ -651,7 +734,7 @@
     public static final int AXIS_RZ = 14;
 
     /**
-     * Constant used to identify the Hat X axis of a motion event.
+     * 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.
@@ -667,7 +750,7 @@
     public static final int AXIS_HAT_X = 15;
 
     /**
-     * Constant used to identify the Hat Y axis of a motion event.
+     * 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.
@@ -683,7 +766,7 @@
     public static final int AXIS_HAT_Y = 16;
 
     /**
-     * Constant used to identify the Left Trigger axis of a motion event.
+     * Axis constant: Left Trigger axis of a motion event.
      * <p>
      * <ul>
      * <li>For a joystick, reports the absolute position of the left trigger control.
@@ -699,7 +782,7 @@
     public static final int AXIS_LTRIGGER = 17;
 
     /**
-     * Constant used to identify the Right Trigger axis of a motion event.
+     * Axis constant: Right Trigger axis of a motion event.
      * <p>
      * <ul>
      * <li>For a joystick, reports the absolute position of the right trigger control.
@@ -715,7 +798,7 @@
     public static final int AXIS_RTRIGGER = 18;
 
     /**
-     * Constant used to identify the Throttle axis of a motion event.
+     * Axis constant: Throttle axis of a motion event.
      * <p>
      * <ul>
      * <li>For a joystick, reports the absolute position of the throttle control.
@@ -731,7 +814,7 @@
     public static final int AXIS_THROTTLE = 19;
 
     /**
-     * Constant used to identify the Rudder axis of a motion event.
+     * Axis constant: Rudder axis of a motion event.
      * <p>
      * <ul>
      * <li>For a joystick, reports the absolute position of the rudder control.
@@ -747,7 +830,7 @@
     public static final int AXIS_RUDDER = 20;
 
     /**
-     * Constant used to identify the Wheel axis of a motion event.
+     * Axis constant: Wheel axis of a motion event.
      * <p>
      * <ul>
      * <li>For a joystick, reports the absolute position of the steering wheel control.
@@ -763,7 +846,7 @@
     public static final int AXIS_WHEEL = 21;
 
     /**
-     * Constant used to identify the Gas axis of a motion event.
+     * Axis constant: Gas axis of a motion event.
      * <p>
      * <ul>
      * <li>For a joystick, reports the absolute position of the gas (accelerator) control.
@@ -780,7 +863,7 @@
     public static final int AXIS_GAS = 22;
 
     /**
-     * Constant used to identify the Brake axis of a motion event.
+     * Axis constant: Brake axis of a motion event.
      * <p>
      * <ul>
      * <li>For a joystick, reports the absolute position of the brake control.
@@ -796,7 +879,24 @@
     public static final int AXIS_BRAKE = 23;
 
     /**
-     * Constant used to identify the Generic 1 axis of a motion event.
+     * Axis constant: Distance axis of a motion event.
+     * <p>
+     * <ul>
+     * <li>For a stylus, reports the distance of the stylus from the screen.
+     * The value is normalized to a range from 0.0 (direct contact) to 1.0 (furthest measurable
+     * distance).
+     * </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: Generic 1 axis of a motion event.
      * The interpretation of a generic axis is device-specific.
      *
      * @see #getAxisValue(int, int)
@@ -807,7 +907,7 @@
     public static final int AXIS_GENERIC_1 = 32;
 
     /**
-     * Constant used to identify the Generic 2 axis of a motion event.
+     * Axis constant: Generic 2 axis of a motion event.
      * The interpretation of a generic axis is device-specific.
      *
      * @see #getAxisValue(int, int)
@@ -818,7 +918,7 @@
     public static final int AXIS_GENERIC_2 = 33;
 
     /**
-     * Constant used to identify the Generic 3 axis of a motion event.
+     * Axis constant: Generic 3 axis of a motion event.
      * The interpretation of a generic axis is device-specific.
      *
      * @see #getAxisValue(int, int)
@@ -829,7 +929,7 @@
     public static final int AXIS_GENERIC_3 = 34;
 
     /**
-     * Constant used to identify the Generic 4 axis of a motion event.
+     * Axis constant: Generic 4 axis of a motion event.
      * The interpretation of a generic axis is device-specific.
      *
      * @see #getAxisValue(int, int)
@@ -840,7 +940,7 @@
     public static final int AXIS_GENERIC_4 = 35;
 
     /**
-     * Constant used to identify the Generic 5 axis of a motion event.
+     * Axis constant: Generic 5 axis of a motion event.
      * The interpretation of a generic axis is device-specific.
      *
      * @see #getAxisValue(int, int)
@@ -851,7 +951,7 @@
     public static final int AXIS_GENERIC_5 = 36;
 
     /**
-     * Constant used to identify the Generic 6 axis of a motion event.
+     * Axis constant: Generic 6 axis of a motion event.
      * The interpretation of a generic axis is device-specific.
      *
      * @see #getAxisValue(int, int)
@@ -862,7 +962,7 @@
     public static final int AXIS_GENERIC_6 = 37;
 
     /**
-     * Constant used to identify the Generic 7 axis of a motion event.
+     * Axis constant: Generic 7 axis of a motion event.
      * The interpretation of a generic axis is device-specific.
      *
      * @see #getAxisValue(int, int)
@@ -873,7 +973,7 @@
     public static final int AXIS_GENERIC_7 = 38;
 
     /**
-     * Constant used to identify the Generic 8 axis of a motion event.
+     * Axis constant: Generic 8 axis of a motion event.
      * The interpretation of a generic axis is device-specific.
      *
      * @see #getAxisValue(int, int)
@@ -884,7 +984,7 @@
     public static final int AXIS_GENERIC_8 = 39;
 
     /**
-     * Constant used to identify the Generic 9 axis of a motion event.
+     * Axis constant: Generic 9 axis of a motion event.
      * The interpretation of a generic axis is device-specific.
      *
      * @see #getAxisValue(int, int)
@@ -895,7 +995,7 @@
     public static final int AXIS_GENERIC_9 = 40;
 
     /**
-     * Constant used to identify the Generic 10 axis of a motion event.
+     * Axis constant: Generic 10 axis of a motion event.
      * The interpretation of a generic axis is device-specific.
      *
      * @see #getAxisValue(int, int)
@@ -906,7 +1006,7 @@
     public static final int AXIS_GENERIC_10 = 41;
 
     /**
-     * Constant used to identify the Generic 11 axis of a motion event.
+     * Axis constant: Generic 11 axis of a motion event.
      * The interpretation of a generic axis is device-specific.
      *
      * @see #getAxisValue(int, int)
@@ -917,7 +1017,7 @@
     public static final int AXIS_GENERIC_11 = 42;
 
     /**
-     * Constant used to identify the Generic 12 axis of a motion event.
+     * Axis constant: Generic 12 axis of a motion event.
      * The interpretation of a generic axis is device-specific.
      *
      * @see #getAxisValue(int, int)
@@ -928,7 +1028,7 @@
     public static final int AXIS_GENERIC_12 = 43;
 
     /**
-     * Constant used to identify the Generic 13 axis of a motion event.
+     * Axis constant: Generic 13 axis of a motion event.
      * The interpretation of a generic axis is device-specific.
      *
      * @see #getAxisValue(int, int)
@@ -939,7 +1039,7 @@
     public static final int AXIS_GENERIC_13 = 44;
 
     /**
-     * Constant used to identify the Generic 14 axis of a motion event.
+     * Axis constant: Generic 14 axis of a motion event.
      * The interpretation of a generic axis is device-specific.
      *
      * @see #getAxisValue(int, int)
@@ -950,7 +1050,7 @@
     public static final int AXIS_GENERIC_14 = 45;
 
     /**
-     * Constant used to identify the Generic 15 axis of a motion event.
+     * Axis constant: Generic 15 axis of a motion event.
      * The interpretation of a generic axis is device-specific.
      *
      * @see #getAxisValue(int, int)
@@ -961,7 +1061,7 @@
     public static final int AXIS_GENERIC_15 = 46;
 
     /**
-     * Constant used to identify the Generic 16 axis of a motion event.
+     * Axis constant: Generic 16 axis of a motion event.
      * The interpretation of a generic axis is device-specific.
      *
      * @see #getAxisValue(int, int)
@@ -977,7 +1077,7 @@
 
     // Symbolic names of all axes.
     private static final SparseArray<String> AXIS_SYMBOLIC_NAMES = new SparseArray<String>();
-    private static void populateAxisSymbolicNames() {
+    static {
         SparseArray<String> names = AXIS_SYMBOLIC_NAMES;
         names.append(AXIS_X, "AXIS_X");
         names.append(AXIS_Y, "AXIS_Y");
@@ -1003,6 +1103,7 @@
         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_GENERIC_1, "AXIS_GENERIC_1");
         names.append(AXIS_GENERIC_2, "AXIS_GENERIC_2");
         names.append(AXIS_GENERIC_3, "AXIS_GENERIC_3");
@@ -1021,8 +1122,169 @@
         names.append(AXIS_GENERIC_16, "AXIS_GENERIC_16");
     }
 
+    /**
+     * Button constant: Primary button (left mouse button, stylus tip).
+     *
+     * @see #getButtonState
+     */
+    public static final int BUTTON_PRIMARY = 1 << 0;
+
+    /**
+     * Button constant: Secondary button (right mouse button, stylus barrel).
+     *
+     * @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: Eraser button pressed (stylus end).
+     *
+     * @see #getButtonState
+     */
+    public static final int BUTTON_ERASER = 1 << 5;
+
+    // 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_ERASER",
+        "0x00000040",
+        "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",
+    };
+
+    /**
+     * 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 directly touching the display.
+     *
+     * This is a <em>direct</em> positioning tool.
+     *
+     * @see #getToolType
+     */
+    public static final int TOOL_TYPE_FINGER = 1;
+
+    /**
+     * Tool type constant: The tool is a stylus directly touching the display
+     * or hovering slightly above it.
+     *
+     * This is a <em>direct</em> positioning tool.
+     *
+     * @see #getToolType
+     */
+    public static final int TOOL_TYPE_STYLUS = 2;
+
+    /**
+     * Tool type constant: The tool is a mouse or trackpad that translates
+     * relative motions into cursor movements on the display.
+     *
+     * This is an <em>indirect</em> positioning tool.
+     *
+     * @see #getToolType
+     */
+    public static final int TOOL_TYPE_MOUSE = 3;
+
+    /**
+     * Tool type constant: The tool is a finger on a touch pad that is not
+     * directly attached to the display.  Finger movements on the touch pad
+     * may be translated into touches on the display, possibly with visual feedback.
+     *
+     * This is an <em>indirect</em> positioning tool.
+     *
+     * @see #getToolType
+     */
+    public static final int TOOL_TYPE_INDIRECT_FINGER = 4;
+
+    /**
+     * Tool type constant: The tool is a stylus on a digitizer tablet that is not
+     * attached to the display.  Stylus movements on the digitizer may be translated
+     * into touches on the display, possibly with visual feedback.
+     *
+     * This is an <em>indirect</em> positioning tool.
+     *
+     * @see #getToolType
+     */
+    public static final int TOOL_TYPE_INDIRECT_STYLUS = 5;
+
+    // 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 {
-        populateAxisSymbolicNames();
+        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_INDIRECT_FINGER, "TOOL_TYPE_INDIRECT_FINGER");
+        names.append(TOOL_TYPE_INDIRECT_STYLUS, "TOOL_TYPE_INDIRECT_STYLUS");
     }
 
     // Private value for history pos that obtains the current sample.
@@ -1035,10 +1297,23 @@
 
     // Shared temporary objects used when translating coordinates supplied by
     // the caller into single element PointerCoords and pointer id arrays.
-    // Must lock gTmpPointerCoords prior to use.
-    private static final PointerCoords[] gTmpPointerCoords =
-            new PointerCoords[] { new PointerCoords() };
-    private static final int[] gTmpPointerIds = new int[] { 0 /*always 0*/ };
+    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.
     private int mNativePtr;
@@ -1048,10 +1323,11 @@
     private boolean mRecycled;
 
     private static native int nativeInitialize(int nativePtr,
-            int deviceId, int source, int action, int flags, int edgeFlags, int metaState,
+            int deviceId, int source, int action, int flags, int edgeFlags,
+            int metaState, int buttonState,
             float xOffset, float yOffset, float xPrecision, float yPrecision,
             long downTimeNanos, long eventTimeNanos,
-            int pointerCount, int[] pointerIds, PointerCoords[] pointerCoords);
+            int pointerCount, PointerProperties[] pointerIds, PointerCoords[] pointerCoords);
     private static native int nativeCopy(int destNativePtr, int sourceNativePtr,
             boolean keepHistory);
     private static native void nativeDispose(int nativePtr);
@@ -1069,13 +1345,18 @@
     private static native int nativeGetEdgeFlags(int nativePtr);
     private static native void nativeSetEdgeFlags(int nativePtr, int action);
     private static native int nativeGetMetaState(int nativePtr);
+    private static native int nativeGetButtonState(int nativePtr);
     private static native void nativeOffsetLocation(int nativePtr, float deltaX, float deltaY);
+    private static native float nativeGetXOffset(int nativePtr);
+    private static native float nativeGetYOffset(int nativePtr);
     private static native float nativeGetXPrecision(int nativePtr);
     private static native float nativeGetYPrecision(int nativePtr);
     private static native long nativeGetDownTimeNanos(int nativePtr);
+    private static native void nativeSetDownTimeNanos(int nativePtr, long downTime);
 
     private static native int nativeGetPointerCount(int nativePtr);
     private static native int nativeGetPointerId(int nativePtr, int pointerIndex);
+    private static native int nativeGetToolType(int nativePtr, int pointerIndex);
     private static native int nativeFindPointerIndex(int nativePtr, int pointerId);
 
     private static native int nativeGetHistorySize(int nativePtr);
@@ -1086,6 +1367,8 @@
             int axis, int pointerIndex, int historyPos);
     private static native void nativeGetPointerCoords(int nativePtr,
             int pointerIndex, int historyPos, PointerCoords outPointerCoords);
+    private static native void nativeGetPointerProperties(int nativePtr,
+            int pointerIndex, PointerProperties outPointerProperties);
 
     private static native void nativeScale(int nativePtr, float scale);
     private static native void nativeTransform(int nativePtr, Matrix matrix);
@@ -1127,16 +1410,58 @@
     /**
      * 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 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 pointers The number of points that will be in this event.
-     * @param pointerIds An array of <em>pointers</em> values providing
+     * @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.
+     */
+    static public 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) {
+        MotionEvent ev = obtain();
+        ev.mNativePtr = nativeInitialize(ev.mNativePtr,
+                deviceId, source, action, flags, edgeFlags, metaState, buttonState,
+                0, 0, xPrecision, yPrecision,
+                downTime * NS_PER_MS, eventTime * NS_PER_MS,
+                pointerCount, pointerProperties, pointerCoords);
+        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 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>pointers</em> values providing
+     * @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.
@@ -1149,18 +1474,26 @@
      * 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 pointers, int[] pointerIds, PointerCoords[] pointerCoords,
+            int action, int pointerCount, int[] pointerIds, PointerCoords[] pointerCoords,
             int metaState, float xPrecision, float yPrecision, int deviceId,
             int edgeFlags, int source, int flags) {
-        MotionEvent ev = obtain();
-        ev.mNativePtr = nativeInitialize(ev.mNativePtr,
-                deviceId, source, action, flags, edgeFlags, metaState,
-                0, 0, xPrecision, yPrecision,
-                downTime * NS_PER_MS, eventTime * NS_PER_MS,
-                pointers, pointerIds, pointerCoords);
-        return ev;
+        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);
+        }
     }
 
     /**
@@ -1195,20 +1528,25 @@
     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) {
-        synchronized (gTmpPointerCoords) {
-            final PointerCoords pc = gTmpPointerCoords[0];
-            pc.clear();
-            pc.x = x;
-            pc.y = y;
-            pc.pressure = pressure;
-            pc.size = size;
+        MotionEvent ev = obtain();
+        synchronized (gSharedTempLock) {
+            ensureSharedTempPointerCapacity(1);
+            final PointerProperties[] pp = gSharedTempPointerProperties;
+            pp[0].clear();
+            pp[0].id = 0;
 
-            MotionEvent ev = obtain();
+            final PointerCoords pc[] = gSharedTempPointerCoords;
+            pc[0].clear();
+            pc[0].x = x;
+            pc[0].y = y;
+            pc[0].pressure = pressure;
+            pc[0].size = size;
+
             ev.mNativePtr = nativeInitialize(ev.mNativePtr,
-                    deviceId, InputDevice.SOURCE_UNKNOWN, action, 0, edgeFlags, metaState,
+                    deviceId, InputDevice.SOURCE_UNKNOWN, action, 0, edgeFlags, metaState, 0,
                     0, 0, xPrecision, yPrecision,
                     downTime * NS_PER_MS, eventTime * NS_PER_MS,
-                    1, gTmpPointerIds, gTmpPointerCoords);
+                    1, pp, pc);
             return ev;
         }
     }
@@ -1222,7 +1560,7 @@
      * @param eventTime  The 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 pointers The number of pointers that are active in this event.
+     * @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
@@ -1248,7 +1586,7 @@
      */
     @Deprecated
     static public MotionEvent obtain(long downTime, long eventTime, int action,
-            int pointers, float x, float y, float pressure, float size, int metaState,
+            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);
@@ -1444,6 +1782,16 @@
     }
 
     /**
+     * Sets the time (in ms) when the user originally pressed down to start
+     * a stream of position events.
+     *
+     * @hide
+     */
+    public final void setDownTime(long downTime) {
+        nativeSetDownTimeNanos(mNativePtr, downTime * NS_PER_MS);
+    }
+
+    /**
      * Returns the time (in ms) when this specific event was generated.
      */
     public final long getEventTime() {
@@ -1582,7 +1930,27 @@
     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
+     * @see #TOOL_TYPE_INDIRECT_FINGER
+     * @see #TOOL_TYPE_INDIRECT_STYLUS
+     */
+    public final int getToolType(int pointerIndex) {
+        return nativeGetToolType(mNativePtr, pointerIndex);
+    }
+
     /**
      * Given a pointer identifier, find the index of its data in the event.
      * 
@@ -1594,7 +1962,7 @@
     public final int findPointerIndex(int pointerId) {
         return nativeFindPointerIndex(mNativePtr, pointerId);
     }
-    
+
     /**
      * Returns the X coordinate of this event for the given pointer
      * <em>index</em> (use {@link #getPointerId(int)} to find the pointer
@@ -1770,6 +2138,21 @@
     }
 
     /**
+     * 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}.
@@ -1784,6 +2167,22 @@
     }
 
     /**
+     * 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_ERASER
+     */
+    public final int getButtonState() {
+        return nativeGetButtonState(mNativePtr);
+    }
+
+    /**
      * Returns the original raw X coordinate of this event.  For touch
      * events on the screen, this is the original location of the event
      * on the screen, before it had been adjusted for the containing window
@@ -2297,14 +2696,16 @@
      */
     public final void addBatch(long eventTime, float x, float y,
             float pressure, float size, int metaState) {
-        synchronized (gTmpPointerCoords) {
-            final PointerCoords pc = gTmpPointerCoords[0];
-            pc.clear();
-            pc.x = x;
-            pc.y = y;
-            pc.pressure = pressure;
-            pc.size = size;
-            nativeAddBatch(mNativePtr, eventTime * NS_PER_MS, gTmpPointerCoords, metaState);
+        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);
         }
     }
 
@@ -2323,30 +2724,187 @@
         nativeAddBatch(mNativePtr, eventTime * NS_PER_MS, pointerCoords, metaState);
     }
 
+    /**
+     * 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.mNativePtr = nativeInitialize(ev.mNativePtr,
+                    nativeGetDeviceId(mNativePtr), nativeGetSource(mNativePtr),
+                    nativeGetAction(mNativePtr), nativeGetFlags(mNativePtr),
+                    nativeGetEdgeFlags(mNativePtr), nativeGetMetaState(mNativePtr),
+                    nativeGetButtonState(mNativePtr),
+                    nativeGetXOffset(mNativePtr), nativeGetYOffset(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
+     */
+    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.
+     * @hide
+     */
+    public final MotionEvent split(int idBits) {
+        MotionEvent ev = obtain();
+        synchronized (gSharedTempLock) {
+            final int oldPointerCount = nativeGetPointerCount(mNativePtr);
+            ensureSharedTempPointerCapacity(oldPointerCount);
+            final PointerProperties[] pp = gSharedTempPointerProperties;
+            final PointerCoords[] pc = gSharedTempPointerCoords;
+            final int[] map = gSharedTempPointerIndexMap;
+
+            final int oldAction = nativeGetAction(mNativePtr);
+            final int oldActionMasked = oldAction & ACTION_MASK;
+            final int oldActionPointerIndex = (oldAction & ACTION_POINTER_INDEX_MASK)
+                    >> ACTION_POINTER_INDEX_SHIFT;
+            int newActionPointerIndex = -1;
+            int newPointerCount = 0;
+            int newIdBits = 0;
+            for (int i = 0; i < oldPointerCount; i++) {
+                nativeGetPointerProperties(mNativePtr, i, pp[newPointerCount]);
+                final int idBit = 1 << pp[newPointerCount].id;
+                if ((idBit & idBits) != 0) {
+                    if (i == oldActionPointerIndex) {
+                        newActionPointerIndex = newPointerCount;
+                    }
+                    map[newPointerCount] = i;
+                    newPointerCount += 1;
+                    newIdBits |= idBit;
+                }
+            }
+
+            if (newPointerCount == 0) {
+                throw new IllegalArgumentException("idBits did not match any ids in the event");
+            }
+
+            final int newAction;
+            if (oldActionMasked == ACTION_POINTER_DOWN || oldActionMasked == ACTION_POINTER_UP) {
+                if (newActionPointerIndex < 0) {
+                    // An unrelated pointer changed.
+                    newAction = ACTION_MOVE;
+                } else if (newPointerCount == 1) {
+                    // The first/last pointer went down/up.
+                    newAction = oldActionMasked == ACTION_POINTER_DOWN
+                            ? ACTION_DOWN : ACTION_UP;
+                } else {
+                    // A secondary pointer went down/up.
+                    newAction = oldActionMasked
+                            | (newActionPointerIndex << ACTION_POINTER_INDEX_SHIFT);
+                }
+            } else {
+                // Simple up/down/cancel/move or other motion action.
+                newAction = oldAction;
+            }
+
+            final int historySize = nativeGetHistorySize(mNativePtr);
+            for (int h = 0; h <= historySize; h++) {
+                final int historyPos = h == historySize ? HISTORY_CURRENT : h;
+
+                for (int i = 0; i < newPointerCount; i++) {
+                    nativeGetPointerCoords(mNativePtr, map[i], historyPos, pc[i]);
+                }
+
+                final long eventTimeNanos = nativeGetEventTimeNanos(mNativePtr, historyPos);
+                if (h == 0) {
+                    ev.mNativePtr = nativeInitialize(ev.mNativePtr,
+                            nativeGetDeviceId(mNativePtr), nativeGetSource(mNativePtr),
+                            newAction, nativeGetFlags(mNativePtr),
+                            nativeGetEdgeFlags(mNativePtr), nativeGetMetaState(mNativePtr),
+                            nativeGetButtonState(mNativePtr),
+                            nativeGetXOffset(mNativePtr), nativeGetYOffset(mNativePtr),
+                            nativeGetXPrecision(mNativePtr), nativeGetYPrecision(mNativePtr),
+                            nativeGetDownTimeNanos(mNativePtr), eventTimeNanos,
+                            newPointerCount, pp, pc);
+                } else {
+                    nativeAddBatch(ev.mNativePtr, eventTimeNanos, pc, 0);
+                }
+            }
+            return ev;
+        }
+    }
+
     @Override
     public String toString() {
-        return "MotionEvent{" + Integer.toHexString(System.identityHashCode(this))
-            + " pointerId=" + getPointerId(0)
-            + " action=" + actionToString(getAction())
-            + " x=" + getX()
-            + " y=" + getY()
-            + " pressure=" + getPressure()
-            + " size=" + getSize()
-            + " touchMajor=" + getTouchMajor()
-            + " touchMinor=" + getTouchMinor()
-            + " toolMajor=" + getToolMajor()
-            + " toolMinor=" + getToolMinor()
-            + " orientation=" + getOrientation()
-            + " meta=" + KeyEvent.metaStateToString(getMetaState())
-            + " pointerCount=" + getPointerCount()
-            + " historySize=" + getHistorySize()
-            + " flags=0x" + Integer.toHexString(getFlags())
-            + " edgeFlags=0x" + Integer.toHexString(getEdgeFlags())
-            + " device=" + getDeviceId()
-            + " source=0x" + Integer.toHexString(getSource())
-            + (getPointerCount() > 1 ?
-                " pointerId2=" + getPointerId(1) + " x2=" + getX(1) + " y2=" + getY(1) : "")
-            + "}";
+        StringBuilder msg = new StringBuilder();
+        msg.append("MotionEvent { action=").append(actionToString(getAction()));
+
+        final int pointerCount = getPointerCount();
+        for (int i = 0; i < pointerCount; i++) {
+            msg.append(", id[").append(i).append("]=").append(getPointerId(i));
+            msg.append(", x[").append(i).append("]=").append(getX(i));
+            msg.append(", y[").append(i).append("]=").append(getY(i));
+            msg.append(", toolType[").append(i).append("]=").append(
+                    toolTypeToString(getToolType(i)));
+        }
+
+        msg.append(", buttonState=").append(KeyEvent.metaStateToString(getButtonState()));
+        msg.append(", metaState=").append(KeyEvent.metaStateToString(getMetaState()));
+        msg.append(", flags=0x").append(Integer.toHexString(getFlags()));
+        msg.append(", edgeFlags=0x").append(Integer.toHexString(getEdgeFlags()));
+        msg.append(", pointerCount=").append(pointerCount);
+        msg.append(", historySize=").append(getHistorySize());
+        msg.append(", eventTime=").append(getEventTime());
+        msg.append(", downTime=").append(getDownTime());
+        msg.append(", deviceId=").append(getDeviceId());
+        msg.append(", source=0x").append(Integer.toHexString(getSource()));
+        msg.append(" }");
+        return msg.toString();
     }
 
     /**
@@ -2429,6 +2987,55 @@
         }
     }
 
+    /**
+     * 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 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(int toolType) {
+        String symbolicName = TOOL_TYPE_SYMBOLIC_NAMES.get(toolType);
+        return symbolicName != null ? symbolicName : Integer.toString(toolType);
+    }
+
     public static final Parcelable.Creator<MotionEvent> CREATOR
             = new Parcelable.Creator<MotionEvent>() {
         public MotionEvent createFromParcel(Parcel in) {
@@ -2456,8 +3063,9 @@
     /**
      * Transfer object for pointer coordinates.
      * 
-     * Objects of this type can be used to manufacture new {@link MotionEvent} objects
-     * and to query pointer coordinate information in bulk.
+     * 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.
@@ -2483,6 +3091,15 @@
             copyFrom(other);
         }
 
+        /** @hide */
+        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.
          *
@@ -2743,4 +3360,71 @@
             }
         }
     }
+
+    /**
+     * 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 */
+        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 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;
+        }
+    }
 }
diff --git a/core/java/android/view/View.java b/core/java/android/view/View.java
index 791ffb9..4ee3a47 100644
--- a/core/java/android/view/View.java
+++ b/core/java/android/view/View.java
@@ -3173,6 +3173,23 @@
     }
 
     /**
+     * Performs button-related actions during a touch down event.
+     *
+     * @param event The event.
+     * @return True if the down was consumed.
+     *
+     * @hide
+     */
+    protected boolean performButtonActionOnTouchDown(MotionEvent event) {
+        if ((event.getButtonState() & MotionEvent.BUTTON_SECONDARY) != 0) {
+            if (showContextMenu(event.getX(), event.getY(), event.getMetaState())) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
      * Bring up the context menu for this view.
      *
      * @return Whether a context menu was displayed.
@@ -3182,6 +3199,20 @@
     }
 
     /**
+     * Bring up the context menu for this view, referring to the item under the specified point.
+     *
+     * @param x The referenced x coordinate.
+     * @param y The referenced y coordinate.
+     * @param metaState The keyboard modifiers that were pressed.
+     * @return Whether a context menu was displayed.
+     *
+     * @hide
+     */
+    public boolean showContextMenu(float x, float y, int metaState) {
+        return showContextMenu();
+    }
+
+    /**
      * Start an action mode.
      *
      * @param callback Callback that will control the lifecycle of the action mode
@@ -5535,6 +5566,10 @@
                 case MotionEvent.ACTION_DOWN:
                     mHasPerformedLongPress = false;
 
+                    if (performButtonActionOnTouchDown(event)) {
+                        break;
+                    }
+
                     // Walk up the hierarchy to determine if we're inside a scrolling container.
                     boolean isInScrollingContainer = false;
                     ViewParent p = getParent();
diff --git a/core/java/android/view/ViewGroup.java b/core/java/android/view/ViewGroup.java
index 35cca4f..f84b33b 100644
--- a/core/java/android/view/ViewGroup.java
+++ b/core/java/android/view/ViewGroup.java
@@ -129,11 +129,6 @@
     // First touch target in the linked list of touch targets.
     private TouchTarget mFirstTouchTarget;
 
-    // Temporary arrays for splitting pointers.
-    private int[] mTmpPointerIndexMap;
-    private int[] mTmpPointerIds;
-    private MotionEvent.PointerCoords[] mTmpPointerCoords;
-
     // For debugging only.  You can see these in hierarchyviewer.
     @SuppressWarnings({"FieldCanBeLocal", "UnusedDeclaration"})
     @ViewDebug.ExportedProperty(category = "events")
@@ -1723,141 +1718,38 @@
         }
 
         // Calculate the number of pointers to deliver.
-        final int oldPointerCount = event.getPointerCount();
-        int newPointerCount = 0;
-        if (desiredPointerIdBits == TouchTarget.ALL_POINTER_IDS) {
-            newPointerCount = oldPointerCount;
-        } else {
-            for (int i = 0; i < oldPointerCount; i++) {
-                final int pointerId = event.getPointerId(i);
-                final int pointerIdBit = 1 << pointerId;
-                if ((pointerIdBit & desiredPointerIdBits) != 0) {
-                    newPointerCount += 1;
-                }
-            }
-        }
+        final int oldPointerIdBits = event.getPointerIdBits();
+        final int newPointerIdBits = oldPointerIdBits & desiredPointerIdBits;
 
         // If for some reason we ended up in an inconsistent state where it looks like we
         // might produce a motion event with no pointers in it, then drop the event.
-        if (newPointerCount == 0) {
+        if (newPointerIdBits == 0) {
             return false;
         }
 
         // If the number of pointers is the same and we don't need to perform any fancy
         // irreversible transformations, then we can reuse the motion event for this
         // dispatch as long as we are careful to revert any changes we make.
-        final boolean reuse = newPointerCount == oldPointerCount
-                && (child == null || child.hasIdentityMatrix());
-        if (reuse) {
-            if (child == null) {
-                handled = super.dispatchTouchEvent(event);
-            } else {
-                final float offsetX = mScrollX - child.mLeft;
-                final float offsetY = mScrollY - child.mTop;
-                event.offsetLocation(offsetX, offsetY);
+        // Otherwise we need to make a copy.
+        final MotionEvent transformedEvent;
+        if (newPointerIdBits == oldPointerIdBits) {
+            if (child == null || child.hasIdentityMatrix()) {
+                if (child == null) {
+                    handled = super.dispatchTouchEvent(event);
+                } else {
+                    final float offsetX = mScrollX - child.mLeft;
+                    final float offsetY = mScrollY - child.mTop;
+                    event.offsetLocation(offsetX, offsetY);
 
-                handled = child.dispatchTouchEvent(event);
+                    handled = child.dispatchTouchEvent(event);
 
-                event.offsetLocation(-offsetX, -offsetY);
+                    event.offsetLocation(-offsetX, -offsetY);
+                }
+                return handled;
             }
-            return handled;
-        }
-
-        // Make a copy of the event.
-        // If the number of pointers is different, then we need to filter out irrelevant pointers
-        // as we make a copy of the motion event.
-        MotionEvent transformedEvent;
-        if (newPointerCount == oldPointerCount) {
             transformedEvent = MotionEvent.obtain(event);
         } else {
-            growTmpPointerArrays(newPointerCount);
-            final int[] newPointerIndexMap = mTmpPointerIndexMap;
-            final int[] newPointerIds = mTmpPointerIds;
-            final MotionEvent.PointerCoords[] newPointerCoords = mTmpPointerCoords;
-
-            int newPointerIndex = 0;
-            int oldPointerIndex = 0;
-            while (newPointerIndex < newPointerCount) {
-                final int pointerId = event.getPointerId(oldPointerIndex);
-                final int pointerIdBits = 1 << pointerId;
-                if ((pointerIdBits & desiredPointerIdBits) != 0) {
-                    newPointerIndexMap[newPointerIndex] = oldPointerIndex;
-                    newPointerIds[newPointerIndex] = pointerId;
-                    if (newPointerCoords[newPointerIndex] == null) {
-                        newPointerCoords[newPointerIndex] = new MotionEvent.PointerCoords();
-                    }
-
-                    newPointerIndex += 1;
-                }
-                oldPointerIndex += 1;
-            }
-
-            final int newAction;
-            if (cancel) {
-                newAction = MotionEvent.ACTION_CANCEL;
-            } else {
-                final int oldMaskedAction = oldAction & MotionEvent.ACTION_MASK;
-                if (oldMaskedAction == MotionEvent.ACTION_POINTER_DOWN
-                        || oldMaskedAction == MotionEvent.ACTION_POINTER_UP) {
-                    final int changedPointerId = event.getPointerId(
-                            (oldAction & MotionEvent.ACTION_POINTER_INDEX_MASK)
-                                    >> MotionEvent.ACTION_POINTER_INDEX_SHIFT);
-                    final int changedPointerIdBits = 1 << changedPointerId;
-                    if ((changedPointerIdBits & desiredPointerIdBits) != 0) {
-                        if (newPointerCount == 1) {
-                            // The first/last pointer went down/up.
-                            newAction = oldMaskedAction == MotionEvent.ACTION_POINTER_DOWN
-                                    ? MotionEvent.ACTION_DOWN : MotionEvent.ACTION_UP;
-                        } else {
-                            // A secondary pointer went down/up.
-                            int newChangedPointerIndex = 0;
-                            while (newPointerIds[newChangedPointerIndex] != changedPointerId) {
-                                newChangedPointerIndex += 1;
-                            }
-                            newAction = oldMaskedAction | (newChangedPointerIndex
-                                    << MotionEvent.ACTION_POINTER_INDEX_SHIFT);
-                        }
-                    } else {
-                        // An unrelated pointer changed.
-                        newAction = MotionEvent.ACTION_MOVE;
-                    }
-                } else {
-                    // Simple up/down/cancel/move motion action.
-                    newAction = oldMaskedAction;
-                }
-            }
-
-            transformedEvent = null;
-            final int historySize = event.getHistorySize();
-            for (int historyIndex = 0; historyIndex <= historySize; historyIndex++) {
-                for (newPointerIndex = 0; newPointerIndex < newPointerCount; newPointerIndex++) {
-                    final MotionEvent.PointerCoords c = newPointerCoords[newPointerIndex];
-                    oldPointerIndex = newPointerIndexMap[newPointerIndex];
-                    if (historyIndex != historySize) {
-                        event.getHistoricalPointerCoords(oldPointerIndex, historyIndex, c);
-                    } else {
-                        event.getPointerCoords(oldPointerIndex, c);
-                    }
-                }
-
-                final long eventTime;
-                if (historyIndex != historySize) {
-                    eventTime = event.getHistoricalEventTime(historyIndex);
-                } else {
-                    eventTime = event.getEventTime();
-                }
-
-                if (transformedEvent == null) {
-                    transformedEvent = MotionEvent.obtain(
-                            event.getDownTime(), eventTime, newAction,
-                            newPointerCount, newPointerIds, newPointerCoords,
-                            event.getMetaState(), event.getXPrecision(), event.getYPrecision(),
-                            event.getDeviceId(), event.getEdgeFlags(), event.getSource(),
-                            event.getFlags());
-                } else {
-                    transformedEvent.addBatch(eventTime, newPointerCoords, 0);
-                }
-            }
+            transformedEvent = event.split(newPointerIdBits);
         }
 
         // Perform any necessary transformations and dispatch.
@@ -1880,36 +1772,6 @@
     }
 
     /**
-     * Enlarge the temporary pointer arrays for splitting pointers.
-     * May discard contents (but keeps PointerCoords objects to avoid reallocating them).
-     */
-    private void growTmpPointerArrays(int desiredCapacity) {
-        final MotionEvent.PointerCoords[] oldTmpPointerCoords = mTmpPointerCoords;
-        int capacity;
-        if (oldTmpPointerCoords != null) {
-            capacity = oldTmpPointerCoords.length;
-            if (desiredCapacity <= capacity) {
-                return;
-            }
-        } else {
-            capacity = 4;
-        }
-
-        while (capacity < desiredCapacity) {
-            capacity *= 2;
-        }
-
-        mTmpPointerIndexMap = new int[capacity];
-        mTmpPointerIds = new int[capacity];
-        mTmpPointerCoords = new MotionEvent.PointerCoords[capacity];
-
-        if (oldTmpPointerCoords != null) {
-            System.arraycopy(oldTmpPointerCoords, 0, mTmpPointerCoords, 0,
-                    oldTmpPointerCoords.length);
-        }
-    }
-
-    /**
      * Enable or disable the splitting of MotionEvents to multiple children during touch event
      * dispatch. This behavior is enabled by default for applications that target an
      * SDK version of {@link Build.VERSION_CODES#HONEYCOMB} or newer.
diff --git a/core/java/android/widget/AbsListView.java b/core/java/android/widget/AbsListView.java
index df4c4ed..f4300a5 100644
--- a/core/java/android/widget/AbsListView.java
+++ b/core/java/android/widget/AbsListView.java
@@ -2533,6 +2533,21 @@
         return mContextMenuInfo;
     }
 
+    /** @hide */
+    @Override
+    public boolean showContextMenu(float x, float y, int metaState) {
+        final int position = pointToPosition((int)x, (int)y);
+        if (position != INVALID_POSITION) {
+            final long id = mAdapter.getItemId(position);
+            View child = getChildAt(position - mFirstPosition);
+            if (child != null) {
+                mContextMenuInfo = createContextMenuInfo(child, position, id);
+                return super.showContextMenuForChild(AbsListView.this);
+            }
+        }
+        return super.showContextMenu(x, y, metaState);
+    }
+
     @Override
     public boolean showContextMenuForChild(View originalView) {
         final int longPressPosition = getPositionForView(originalView);
@@ -2846,6 +2861,12 @@
                 break;
             }
             }
+
+            if (performButtonActionOnTouchDown(ev)) {
+                if (mTouchMode == TOUCH_MODE_DOWN) {
+                    removeCallbacks(mPendingCheckForTap);
+                }
+            }
             break;
         }
 
diff --git a/core/java/com/android/internal/widget/PointerLocationView.java b/core/java/com/android/internal/widget/PointerLocationView.java
index c34cb9e..d789584 100644
--- a/core/java/com/android/internal/widget/PointerLocationView.java
+++ b/core/java/com/android/internal/widget/PointerLocationView.java
@@ -320,7 +320,8 @@
         }
     }
     
-    private void logPointerCoords(int action, int index, MotionEvent.PointerCoords coords, int id) {
+    private void logPointerCoords(int action, int index, MotionEvent.PointerCoords coords, int id,
+            int toolType, int buttonState) {
         final String prefix;
         switch (action & MotionEvent.ACTION_MASK) {
             case MotionEvent.ACTION_DOWN:
@@ -386,26 +387,16 @@
                 .append("deg")
                 .append(" VScroll=").append(coords.getAxisValue(MotionEvent.AXIS_VSCROLL), 1)
                 .append(" HScroll=").append(coords.getAxisValue(MotionEvent.AXIS_HSCROLL), 1)
+                .append(" ToolType=").append(MotionEvent.toolTypeToString(toolType))
+                .append(" ButtonState=").append(MotionEvent.buttonStateToString(buttonState))
                 .toString());
     }
 
     public void addPointerEvent(MotionEvent event) {
         synchronized (mPointers) {
-            int action = event.getAction();
-            
-            //Log.i(TAG, "Motion: action=0x" + Integer.toHexString(action)
-            //        + " pointers=" + event.getPointerCount());
-            
+            final int action = event.getAction();
             int NP = mPointers.size();
-            
-            //mRect.set(0, 0, getWidth(), mHeaderBottom+1);
-            //invalidate(mRect);
-            //if (mCurDown) {
-            //    mRect.set(mCurX-mCurWidth-3, mCurY-mCurWidth-3,
-            //            mCurX+mCurWidth+3, mCurY+mCurWidth+3);
-            //} else {
-            //    mRect.setEmpty();
-            //}
+
             if (action == MotionEvent.ACTION_DOWN
                     || (action & MotionEvent.ACTION_MASK) == MotionEvent.ACTION_POINTER_DOWN) {
                 final int index = (action & MotionEvent.ACTION_POINTER_INDEX_MASK)
@@ -456,7 +447,8 @@
                     final PointerCoords coords = ps != null ? ps.mCoords : mHoverCoords;
                     event.getHistoricalPointerCoords(i, historyPos, coords);
                     if (mPrintCoords) {
-                        logPointerCoords(action, i, coords, id);
+                        logPointerCoords(action, i, coords, id,
+                                event.getToolType(i), event.getButtonState());
                     }
                     if (ps != null) {
                         ps.addTrace(coords.x, coords.y);
@@ -469,7 +461,8 @@
                 final PointerCoords coords = ps != null ? ps.mCoords : mHoverCoords;
                 event.getPointerCoords(i, coords);
                 if (mPrintCoords) {
-                    logPointerCoords(action, i, coords, id);
+                    logPointerCoords(action, i, coords, id,
+                            event.getToolType(i), event.getButtonState());
                 }
                 if (ps != null) {
                     ps.addTrace(coords.x, coords.y);
@@ -500,12 +493,7 @@
                     ps.addTrace(Float.NaN, Float.NaN);
                 }
             }
-            
-            //if (mCurDown) {
-            //    mRect.union(mCurX-mCurWidth-3, mCurY-mCurWidth-3,
-            //            mCurX+mCurWidth+3, mCurY+mCurWidth+3);
-            //}
-            //invalidate(mRect);
+
             postInvalidate();
         }
     }
diff --git a/core/jni/android_view_MotionEvent.cpp b/core/jni/android_view_MotionEvent.cpp
index 2ede7ec..fef06b2 100644
--- a/core/jni/android_view_MotionEvent.cpp
+++ b/core/jni/android_view_MotionEvent.cpp
@@ -55,6 +55,11 @@
     jfieldID orientation;
 } gPointerCoordsClassInfo;
 
+static struct {
+    jfieldID id;
+    jfieldID toolType;
+} gPointerPropertiesClassInfo;
+
 // ----------------------------------------------------------------------------
 
 MotionEvent* android_view_MotionEvent_getNativePtr(JNIEnv* env, jobject eventObj) {
@@ -115,17 +120,17 @@
     return true;
 }
 
-static bool validatePointerIdsArray(JNIEnv* env, jintArray pointerIdsArray,
+static bool validatePointerPropertiesArray(JNIEnv* env, jobjectArray pointerPropertiesObjArray,
         size_t pointerCount) {
-    if (!pointerIdsArray) {
+    if (!pointerPropertiesObjArray) {
         jniThrowException(env, "java/lang/IllegalArgumentException",
-                "pointerIds array must not be null");
+                "pointerProperties array must not be null");
         return false;
     }
-    size_t length = size_t(env->GetArrayLength(pointerIdsArray));
+    size_t length = size_t(env->GetArrayLength(pointerPropertiesObjArray));
     if (length < pointerCount) {
         jniThrowException(env, "java/lang/IllegalArgumentException",
-                "pointerIds array must be large enough to hold all pointers");
+                "pointerProperties array must be large enough to hold all pointers");
         return false;
     }
     return true;
@@ -174,6 +179,15 @@
     return true;
 }
 
+static bool validatePointerProperties(JNIEnv* env, jobject pointerPropertiesObj) {
+    if (!pointerPropertiesObj) {
+        jniThrowException(env, "java/lang/IllegalArgumentException",
+                "pointerProperties must not be null");
+        return false;
+    }
+    return true;
+}
+
 static void pointerCoordsToNative(JNIEnv* env, jobject pointerCoordsObj,
         float xOffset, float yOffset, PointerCoords* outRawPointerCoords) {
     outRawPointerCoords->clear();
@@ -300,17 +314,36 @@
     env->SetLongField(outPointerCoordsObj, gPointerCoordsClassInfo.mPackedAxisBits, outBits);
 }
 
+static void pointerPropertiesToNative(JNIEnv* env, jobject pointerPropertiesObj,
+        PointerProperties* outPointerProperties) {
+    outPointerProperties->clear();
+    outPointerProperties->id = env->GetIntField(pointerPropertiesObj,
+            gPointerPropertiesClassInfo.id);
+    outPointerProperties->toolType = env->GetIntField(pointerPropertiesObj,
+            gPointerPropertiesClassInfo.toolType);
+}
+
+static void pointerPropertiesFromNative(JNIEnv* env, const PointerProperties* pointerProperties,
+        jobject outPointerPropertiesObj) {
+    env->SetIntField(outPointerPropertiesObj, gPointerPropertiesClassInfo.id,
+            pointerProperties->id);
+    env->SetIntField(outPointerPropertiesObj, gPointerPropertiesClassInfo.toolType,
+            pointerProperties->toolType);
+}
+
 
 // ----------------------------------------------------------------------------
 
 static jint android_view_MotionEvent_nativeInitialize(JNIEnv* env, jclass clazz,
         jint nativePtr,
-        jint deviceId, jint source, jint action, jint flags, jint edgeFlags, jint metaState,
+        jint deviceId, jint source, jint action, jint flags, jint edgeFlags,
+        jint metaState, jint buttonState,
         jfloat xOffset, jfloat yOffset, jfloat xPrecision, jfloat yPrecision,
         jlong downTimeNanos, jlong eventTimeNanos,
-        jint pointerCount, jintArray pointerIdsArray, jobjectArray pointerCoordsObjArray) {
+        jint pointerCount, jobjectArray pointerPropertiesObjArray,
+        jobjectArray pointerCoordsObjArray) {
     if (!validatePointerCount(env, pointerCount)
-            || !validatePointerIdsArray(env, pointerIdsArray, pointerCount)
+            || !validatePointerPropertiesArray(env, pointerPropertiesObjArray, pointerCount)
             || !validatePointerCoordsObjArray(env, pointerCoordsObjArray, pointerCount)) {
         return 0;
     }
@@ -320,29 +353,37 @@
         event = new MotionEvent();
     }
 
+    PointerProperties pointerProperties[pointerCount];
     PointerCoords rawPointerCoords[pointerCount];
 
     for (jint i = 0; i < pointerCount; i++) {
+        jobject pointerPropertiesObj = env->GetObjectArrayElement(pointerPropertiesObjArray, i);
+        if (!pointerPropertiesObj) {
+            goto Error;
+        }
+        pointerPropertiesToNative(env, pointerPropertiesObj, &pointerProperties[i]);
+        env->DeleteLocalRef(pointerPropertiesObj);
+
         jobject pointerCoordsObj = env->GetObjectArrayElement(pointerCoordsObjArray, i);
         if (!pointerCoordsObj) {
             jniThrowNullPointerException(env, "pointerCoords");
-            if (!nativePtr) {
-                delete event;
-            }
-            return 0;
+            goto Error;
         }
         pointerCoordsToNative(env, pointerCoordsObj, xOffset, yOffset, &rawPointerCoords[i]);
         env->DeleteLocalRef(pointerCoordsObj);
     }
 
-    int* pointerIds = static_cast<int*>(env->GetPrimitiveArrayCritical(pointerIdsArray, NULL));
-
-    event->initialize(deviceId, source, action, flags, edgeFlags, metaState,
+    event->initialize(deviceId, source, action, flags, edgeFlags, metaState, buttonState,
             xOffset, yOffset, xPrecision, yPrecision,
-            downTimeNanos, eventTimeNanos, pointerCount, pointerIds, rawPointerCoords);
+            downTimeNanos, eventTimeNanos, pointerCount, pointerProperties, rawPointerCoords);
 
-    env->ReleasePrimitiveArrayCritical(pointerIdsArray, pointerIds, JNI_ABORT);
     return reinterpret_cast<jint>(event);
+
+Error:
+    if (!nativePtr) {
+        delete event;
+    }
+    return 0;
 }
 
 static jint android_view_MotionEvent_nativeCopy(JNIEnv* env, jclass clazz,
@@ -454,12 +495,30 @@
     return event->getMetaState();
 }
 
+static jint android_view_MotionEvent_nativeGetButtonState(JNIEnv* env, jclass clazz,
+        jint nativePtr) {
+    MotionEvent* event = reinterpret_cast<MotionEvent*>(nativePtr);
+    return event->getButtonState();
+}
+
 static void android_view_MotionEvent_nativeOffsetLocation(JNIEnv* env, jclass clazz,
         jint nativePtr, jfloat deltaX, jfloat deltaY) {
     MotionEvent* event = reinterpret_cast<MotionEvent*>(nativePtr);
     return event->offsetLocation(deltaX, deltaY);
 }
 
+static jfloat android_view_MotionEvent_nativeGetXOffset(JNIEnv* env, jclass clazz,
+        jint nativePtr) {
+    MotionEvent* event = reinterpret_cast<MotionEvent*>(nativePtr);
+    return event->getXOffset();
+}
+
+static jfloat android_view_MotionEvent_nativeGetYOffset(JNIEnv* env, jclass clazz,
+        jint nativePtr) {
+    MotionEvent* event = reinterpret_cast<MotionEvent*>(nativePtr);
+    return event->getYOffset();
+}
+
 static jfloat android_view_MotionEvent_nativeGetXPrecision(JNIEnv* env, jclass clazz,
         jint nativePtr) {
     MotionEvent* event = reinterpret_cast<MotionEvent*>(nativePtr);
@@ -478,6 +537,12 @@
     return event->getDownTime();
 }
 
+static void android_view_MotionEvent_nativeSetDownTimeNanos(JNIEnv* env, jclass clazz,
+        jint nativePtr, jlong downTimeNanos) {
+    MotionEvent* event = reinterpret_cast<MotionEvent*>(nativePtr);
+    event->setDownTime(downTimeNanos);
+}
+
 static jint android_view_MotionEvent_nativeGetPointerCount(JNIEnv* env, jclass clazz,
         jint nativePtr) {
     MotionEvent* event = reinterpret_cast<MotionEvent*>(nativePtr);
@@ -494,6 +559,16 @@
     return event->getPointerId(pointerIndex);
 }
 
+static jint android_view_MotionEvent_nativeGetToolType(JNIEnv* env, jclass clazz,
+        jint nativePtr, jint pointerIndex) {
+    MotionEvent* event = reinterpret_cast<MotionEvent*>(nativePtr);
+    size_t pointerCount = event->getPointerCount();
+    if (!validatePointerIndex(env, pointerIndex, pointerCount)) {
+        return -1;
+    }
+    return event->getToolType(pointerIndex);
+}
+
 static jint android_view_MotionEvent_nativeFindPointerIndex(JNIEnv* env, jclass clazz,
         jint nativePtr, jint pointerId) {
     MotionEvent* event = reinterpret_cast<MotionEvent*>(nativePtr);
@@ -581,6 +656,19 @@
             outPointerCoordsObj);
 }
 
+static void android_view_MotionEvent_nativeGetPointerProperties(JNIEnv* env, jclass clazz,
+        jint nativePtr, jint pointerIndex, jobject outPointerPropertiesObj) {
+    MotionEvent* event = reinterpret_cast<MotionEvent*>(nativePtr);
+    size_t pointerCount = event->getPointerCount();
+    if (!validatePointerIndex(env, pointerIndex, pointerCount)
+            || !validatePointerProperties(env, outPointerPropertiesObj)) {
+        return;
+    }
+
+    const PointerProperties* pointerProperties = event->getPointerProperties(pointerIndex);
+    pointerPropertiesFromNative(env, pointerProperties, outPointerPropertiesObj);
+}
+
 static void android_view_MotionEvent_nativeScale(JNIEnv* env, jclass clazz,
         jint nativePtr, jfloat scale) {
     MotionEvent* event = reinterpret_cast<MotionEvent*>(nativePtr);
@@ -630,7 +718,8 @@
 static JNINativeMethod gMotionEventMethods[] = {
     /* name, signature, funcPtr */
     { "nativeInitialize",
-            "(IIIIIIIFFFFJJI[I[Landroid/view/MotionEvent$PointerCoords;)I",
+            "(IIIIIIIIFFFFJJI[Landroid/view/MotionEvent$PointerProperties;"
+                    "[Landroid/view/MotionEvent$PointerCoords;)I",
             (void*)android_view_MotionEvent_nativeInitialize },
     { "nativeCopy",
             "(IIZ)I",
@@ -674,9 +763,18 @@
     { "nativeGetMetaState",
             "(I)I",
             (void*)android_view_MotionEvent_nativeGetMetaState },
+    { "nativeGetButtonState",
+            "(I)I",
+            (void*)android_view_MotionEvent_nativeGetButtonState },
     { "nativeOffsetLocation",
             "(IFF)V",
             (void*)android_view_MotionEvent_nativeOffsetLocation },
+    { "nativeGetXOffset",
+            "(I)F",
+            (void*)android_view_MotionEvent_nativeGetXOffset },
+    { "nativeGetYOffset",
+            "(I)F",
+            (void*)android_view_MotionEvent_nativeGetYOffset },
     { "nativeGetXPrecision",
             "(I)F",
             (void*)android_view_MotionEvent_nativeGetXPrecision },
@@ -686,12 +784,18 @@
     { "nativeGetDownTimeNanos",
             "(I)J",
             (void*)android_view_MotionEvent_nativeGetDownTimeNanos },
+    { "nativeSetDownTimeNanos",
+            "(IJ)V",
+            (void*)android_view_MotionEvent_nativeSetDownTimeNanos },
     { "nativeGetPointerCount",
             "(I)I",
             (void*)android_view_MotionEvent_nativeGetPointerCount },
     { "nativeGetPointerId",
             "(II)I",
             (void*)android_view_MotionEvent_nativeGetPointerId },
+    { "nativeGetToolType",
+            "(II)I",
+            (void*)android_view_MotionEvent_nativeGetToolType },
     { "nativeFindPointerIndex",
             "(II)I",
             (void*)android_view_MotionEvent_nativeFindPointerIndex },
@@ -710,6 +814,9 @@
     { "nativeGetPointerCoords",
             "(IIILandroid/view/MotionEvent$PointerCoords;)V",
             (void*)android_view_MotionEvent_nativeGetPointerCoords },
+    { "nativeGetPointerProperties",
+            "(IILandroid/view/MotionEvent$PointerProperties;)V",
+            (void*)android_view_MotionEvent_nativeGetPointerProperties },
     { "nativeScale",
             "(IF)V",
             (void*)android_view_MotionEvent_nativeScale },
@@ -781,6 +888,13 @@
     GET_FIELD_ID(gPointerCoordsClassInfo.orientation, clazz,
             "orientation", "F");
 
+    FIND_CLASS(clazz, "android/view/MotionEvent$PointerProperties");
+
+    GET_FIELD_ID(gPointerPropertiesClassInfo.id, clazz,
+            "id", "I");
+    GET_FIELD_ID(gPointerPropertiesClassInfo.toolType, clazz,
+            "toolType", "I");
+
     return 0;
 }
 
diff --git a/include/ui/Input.h b/include/ui/Input.h
index c7ebf56..ba1c6b4 100644
--- a/include/ui/Input.h
+++ b/include/ui/Input.h
@@ -157,14 +157,6 @@
 };
 
 /*
- * Button state.
- */
-enum {
-    // Primary button pressed (left mouse button).
-    BUTTON_STATE_PRIMARY = 1 << 0,
-};
-
-/*
  * Describes the basic configuration of input devices that are present.
  */
 struct InputConfiguration {
@@ -235,6 +227,29 @@
 };
 
 /*
+ * Pointer property data.
+ */
+struct PointerProperties {
+    // The id of the pointer.
+    int32_t id;
+
+    // The pointer tool type.
+    int32_t toolType;
+
+    inline void clear() {
+        id = -1;
+        toolType = 0;
+    }
+
+    bool operator==(const PointerProperties& other) const;
+    inline bool operator!=(const PointerProperties& other) const {
+        return !(*this == other);
+    }
+
+    void copyFrom(const PointerProperties& other);
+};
+
+/*
  * Input events.
  */
 class InputEvent : public AInputEvent {
@@ -346,6 +361,8 @@
 
     inline void setMetaState(int32_t metaState) { mMetaState = metaState; }
 
+    inline int32_t getButtonState() const { return mButtonState; }
+
     inline float getXOffset() const { return mXOffset; }
 
     inline float getYOffset() const { return mYOffset; }
@@ -356,9 +373,21 @@
 
     inline nsecs_t getDownTime() const { return mDownTime; }
 
-    inline size_t getPointerCount() const { return mPointerIds.size(); }
+    inline void setDownTime(nsecs_t downTime) { mDownTime = downTime; }
 
-    inline int32_t getPointerId(size_t pointerIndex) const { return mPointerIds[pointerIndex]; }
+    inline size_t getPointerCount() const { return mPointerProperties.size(); }
+
+    inline const PointerProperties* getPointerProperties(size_t pointerIndex) const {
+        return &mPointerProperties[pointerIndex];
+    }
+
+    inline int32_t getPointerId(size_t pointerIndex) const {
+        return mPointerProperties[pointerIndex].id;
+    }
+
+    inline int32_t getToolType(size_t pointerIndex) const {
+        return mPointerProperties[pointerIndex].toolType;
+    }
 
     inline nsecs_t getEventTime() const { return mSampleEventTimes[getHistorySize()]; }
 
@@ -490,6 +519,7 @@
             int32_t flags,
             int32_t edgeFlags,
             int32_t metaState,
+            int32_t buttonState,
             float xOffset,
             float yOffset,
             float xPrecision,
@@ -497,7 +527,7 @@
             nsecs_t downTime,
             nsecs_t eventTime,
             size_t pointerCount,
-            const int32_t* pointerIds,
+            const PointerProperties* pointerProperties,
             const PointerCoords* pointerCoords);
 
     void copyFrom(const MotionEvent* other, bool keepHistory);
@@ -523,7 +553,9 @@
     }
 
     // Low-level accessors.
-    inline const int32_t* getPointerIds() const { return mPointerIds.array(); }
+    inline const PointerProperties* getPointerProperties() const {
+        return mPointerProperties.array();
+    }
     inline const nsecs_t* getSampleEventTimes() const { return mSampleEventTimes.array(); }
     inline const PointerCoords* getSamplePointerCoords() const {
             return mSamplePointerCoords.array();
@@ -534,12 +566,13 @@
     int32_t mFlags;
     int32_t mEdgeFlags;
     int32_t mMetaState;
+    int32_t mButtonState;
     float mXOffset;
     float mYOffset;
     float mXPrecision;
     float mYPrecision;
     nsecs_t mDownTime;
-    Vector<int32_t> mPointerIds;
+    Vector<PointerProperties> mPointerProperties;
     Vector<nsecs_t> mSampleEventTimes;
     Vector<PointerCoords> mSamplePointerCoords;
 };
diff --git a/include/ui/InputTransport.h b/include/ui/InputTransport.h
index 119db81..95e4447 100644
--- a/include/ui/InputTransport.h
+++ b/include/ui/InputTransport.h
@@ -136,6 +136,7 @@
             int32_t action;
             int32_t flags;
             int32_t metaState;
+            int32_t buttonState;
             int32_t edgeFlags;
             nsecs_t downTime;
             float xOffset;
@@ -143,7 +144,7 @@
             float xPrecision;
             float yPrecision;
             size_t pointerCount;
-            int32_t pointerIds[MAX_POINTERS];
+            PointerProperties pointerProperties[MAX_POINTERS];
             size_t sampleCount;
             SampleData sampleData[0]; // variable length
         } motion;
@@ -221,6 +222,7 @@
             int32_t flags,
             int32_t edgeFlags,
             int32_t metaState,
+            int32_t buttonState,
             float xOffset,
             float yOffset,
             float xPrecision,
@@ -228,7 +230,7 @@
             nsecs_t downTime,
             nsecs_t eventTime,
             size_t pointerCount,
-            const int32_t* pointerIds,
+            const PointerProperties* pointerProperties,
             const PointerCoords* pointerCoords);
 
     /* Appends a motion sample to a motion event unless already consumed.
diff --git a/libs/ui/Input.cpp b/libs/ui/Input.cpp
index d811dd7..1ba38a7 100644
--- a/libs/ui/Input.cpp
+++ b/libs/ui/Input.cpp
@@ -373,6 +373,19 @@
 }
 
 
+// --- PointerProperties ---
+
+bool PointerProperties::operator==(const PointerProperties& other) const {
+    return id == other.id
+            && toolType == other.toolType;
+}
+
+void PointerProperties::copyFrom(const PointerProperties& other) {
+    id = other.id;
+    toolType = other.toolType;
+}
+
+
 // --- MotionEvent ---
 
 void MotionEvent::initialize(
@@ -382,6 +395,7 @@
         int32_t flags,
         int32_t edgeFlags,
         int32_t metaState,
+        int32_t buttonState,
         float xOffset,
         float yOffset,
         float xPrecision,
@@ -389,20 +403,21 @@
         nsecs_t downTime,
         nsecs_t eventTime,
         size_t pointerCount,
-        const int32_t* pointerIds,
+        const PointerProperties* pointerProperties,
         const PointerCoords* pointerCoords) {
     InputEvent::initialize(deviceId, source);
     mAction = action;
     mFlags = flags;
     mEdgeFlags = edgeFlags;
     mMetaState = metaState;
+    mButtonState = buttonState;
     mXOffset = xOffset;
     mYOffset = yOffset;
     mXPrecision = xPrecision;
     mYPrecision = yPrecision;
     mDownTime = downTime;
-    mPointerIds.clear();
-    mPointerIds.appendArray(pointerIds, pointerCount);
+    mPointerProperties.clear();
+    mPointerProperties.appendArray(pointerProperties, pointerCount);
     mSampleEventTimes.clear();
     mSamplePointerCoords.clear();
     addSample(eventTime, pointerCoords);
@@ -414,12 +429,13 @@
     mFlags = other->mFlags;
     mEdgeFlags = other->mEdgeFlags;
     mMetaState = other->mMetaState;
+    mButtonState = other->mButtonState;
     mXOffset = other->mXOffset;
     mYOffset = other->mYOffset;
     mXPrecision = other->mXPrecision;
     mYPrecision = other->mYPrecision;
     mDownTime = other->mDownTime;
-    mPointerIds = other->mPointerIds;
+    mPointerProperties = other->mPointerProperties;
 
     if (keepHistory) {
         mSampleEventTimes = other->mSampleEventTimes;
@@ -484,9 +500,9 @@
 }
 
 ssize_t MotionEvent::findPointerIndex(int32_t pointerId) const {
-    size_t pointerCount = mPointerIds.size();
+    size_t pointerCount = mPointerProperties.size();
     for (size_t i = 0; i < pointerCount; i++) {
-        if (mPointerIds.itemAt(i) == pointerId) {
+        if (mPointerProperties.itemAt(i).id == pointerId) {
             return i;
         }
     }
@@ -583,21 +599,25 @@
     mFlags = parcel->readInt32();
     mEdgeFlags = parcel->readInt32();
     mMetaState = parcel->readInt32();
+    mButtonState = parcel->readInt32();
     mXOffset = parcel->readFloat();
     mYOffset = parcel->readFloat();
     mXPrecision = parcel->readFloat();
     mYPrecision = parcel->readFloat();
     mDownTime = parcel->readInt64();
 
-    mPointerIds.clear();
-    mPointerIds.setCapacity(pointerCount);
+    mPointerProperties.clear();
+    mPointerProperties.setCapacity(pointerCount);
     mSampleEventTimes.clear();
     mSampleEventTimes.setCapacity(sampleCount);
     mSamplePointerCoords.clear();
     mSamplePointerCoords.setCapacity(sampleCount * pointerCount);
 
     for (size_t i = 0; i < pointerCount; i++) {
-        mPointerIds.push(parcel->readInt32());
+        mPointerProperties.push();
+        PointerProperties& properties = mPointerProperties.editTop();
+        properties.id = parcel->readInt32();
+        properties.toolType = parcel->readInt32();
     }
 
     while (sampleCount-- > 0) {
@@ -614,7 +634,7 @@
 }
 
 status_t MotionEvent::writeToParcel(Parcel* parcel) const {
-    size_t pointerCount = mPointerIds.size();
+    size_t pointerCount = mPointerProperties.size();
     size_t sampleCount = mSampleEventTimes.size();
 
     parcel->writeInt32(pointerCount);
@@ -626,6 +646,7 @@
     parcel->writeInt32(mFlags);
     parcel->writeInt32(mEdgeFlags);
     parcel->writeInt32(mMetaState);
+    parcel->writeInt32(mButtonState);
     parcel->writeFloat(mXOffset);
     parcel->writeFloat(mYOffset);
     parcel->writeFloat(mXPrecision);
@@ -633,7 +654,9 @@
     parcel->writeInt64(mDownTime);
 
     for (size_t i = 0; i < pointerCount; i++) {
-        parcel->writeInt32(mPointerIds.itemAt(i));
+        const PointerProperties& properties = mPointerProperties.itemAt(i);
+        parcel->writeInt32(properties.id);
+        parcel->writeInt32(properties.toolType);
     }
 
     const PointerCoords* pc = mSamplePointerCoords.array();
diff --git a/libs/ui/InputTransport.cpp b/libs/ui/InputTransport.cpp
index 93d0d1f..ffdfe66 100644
--- a/libs/ui/InputTransport.cpp
+++ b/libs/ui/InputTransport.cpp
@@ -366,6 +366,7 @@
         int32_t flags,
         int32_t edgeFlags,
         int32_t metaState,
+        int32_t buttonState,
         float xOffset,
         float yOffset,
         float xPrecision,
@@ -373,16 +374,17 @@
         nsecs_t downTime,
         nsecs_t eventTime,
         size_t pointerCount,
-        const int32_t* pointerIds,
+        const PointerProperties* pointerProperties,
         const PointerCoords* pointerCoords) {
 #if DEBUG_TRANSPORT_ACTIONS
     LOGD("channel '%s' publisher ~ publishMotionEvent: deviceId=%d, source=0x%x, "
-            "action=0x%x, flags=0x%x, edgeFlags=0x%x, metaState=0x%x, xOffset=%f, yOffset=%f, "
+            "action=0x%x, flags=0x%x, edgeFlags=0x%x, metaState=0x%x, buttonState=0x%x, "
+            "xOffset=%f, yOffset=%f, "
             "xPrecision=%f, yPrecision=%f, downTime=%lld, eventTime=%lld, "
             "pointerCount=%d",
             mChannel->getName().string(),
-            deviceId, source, action, flags, edgeFlags, metaState, xOffset, yOffset,
-            xPrecision, yPrecision, downTime, eventTime, pointerCount);
+            deviceId, source, action, flags, edgeFlags, metaState, buttonState,
+            xOffset, yOffset, xPrecision, yPrecision, downTime, eventTime, pointerCount);
 #endif
 
     if (pointerCount > MAX_POINTERS || pointerCount < 1) {
@@ -400,6 +402,7 @@
     mSharedMessage->motion.flags = flags;
     mSharedMessage->motion.edgeFlags = edgeFlags;
     mSharedMessage->motion.metaState = metaState;
+    mSharedMessage->motion.buttonState = buttonState;
     mSharedMessage->motion.xOffset = xOffset;
     mSharedMessage->motion.yOffset = yOffset;
     mSharedMessage->motion.xPrecision = xPrecision;
@@ -411,7 +414,7 @@
     mSharedMessage->motion.sampleData[0].eventTime = eventTime;
 
     for (size_t i = 0; i < pointerCount; i++) {
-        mSharedMessage->motion.pointerIds[i] = pointerIds[i];
+        mSharedMessage->motion.pointerProperties[i].copyFrom(pointerProperties[i]);
         mSharedMessage->motion.sampleData[0].coords[i].copyFrom(pointerCoords[i]);
     }
 
@@ -694,6 +697,7 @@
             mSharedMessage->motion.flags,
             mSharedMessage->motion.edgeFlags,
             mSharedMessage->motion.metaState,
+            mSharedMessage->motion.buttonState,
             mSharedMessage->motion.xOffset,
             mSharedMessage->motion.yOffset,
             mSharedMessage->motion.xPrecision,
@@ -701,7 +705,7 @@
             mSharedMessage->motion.downTime,
             mSharedMessage->motion.sampleData[0].eventTime,
             mSharedMessage->motion.pointerCount,
-            mSharedMessage->motion.pointerIds,
+            mSharedMessage->motion.pointerProperties,
             mSharedMessage->motion.sampleData[0].coords);
 
     size_t sampleCount = mSharedMessage->motion.sampleCount;
diff --git a/libs/ui/tests/InputEvent_test.cpp b/libs/ui/tests/InputEvent_test.cpp
index b77489e..e48d5b7 100644
--- a/libs/ui/tests/InputEvent_test.cpp
+++ b/libs/ui/tests/InputEvent_test.cpp
@@ -232,7 +232,14 @@
 const float MotionEventTest::Y_OFFSET = 1.1f;
 
 void MotionEventTest::initializeEventWithHistory(MotionEvent* event) {
-    int32_t pointerIds[] = { 1, 2 };
+    PointerProperties pointerProperties[2];
+    pointerProperties[0].clear();
+    pointerProperties[0].id = 1;
+    pointerProperties[0].toolType = AMOTION_EVENT_TOOL_TYPE_FINGER;
+    pointerProperties[1].clear();
+    pointerProperties[1].id = 2;
+    pointerProperties[1].toolType = AMOTION_EVENT_TOOL_TYPE_STYLUS;
+
     PointerCoords pointerCoords[2];
     pointerCoords[0].clear();
     pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_X, 10);
@@ -256,10 +263,10 @@
     pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_ORIENTATION, 28);
     event->initialize(2, AINPUT_SOURCE_TOUCHSCREEN, AMOTION_EVENT_ACTION_MOVE,
             AMOTION_EVENT_FLAG_WINDOW_IS_OBSCURED,
-            AMOTION_EVENT_EDGE_FLAG_TOP, AMETA_ALT_ON,
+            AMOTION_EVENT_EDGE_FLAG_TOP, AMETA_ALT_ON, AMOTION_EVENT_BUTTON_PRIMARY,
             X_OFFSET, Y_OFFSET, 2.0f, 2.1f,
             ARBITRARY_DOWN_TIME, ARBITRARY_EVENT_TIME,
-            2, pointerIds, pointerCoords);
+            2, pointerProperties, pointerCoords);
 
     pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_X, 110);
     pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_Y, 111);
@@ -311,6 +318,7 @@
     ASSERT_EQ(AMOTION_EVENT_FLAG_WINDOW_IS_OBSCURED, event->getFlags());
     ASSERT_EQ(AMOTION_EVENT_EDGE_FLAG_TOP, event->getEdgeFlags());
     ASSERT_EQ(AMETA_ALT_ON, event->getMetaState());
+    ASSERT_EQ(AMOTION_EVENT_BUTTON_PRIMARY, event->getButtonState());
     ASSERT_EQ(X_OFFSET, event->getXOffset());
     ASSERT_EQ(Y_OFFSET, event->getYOffset());
     ASSERT_EQ(2.0f, event->getXPrecision());
@@ -319,7 +327,9 @@
 
     ASSERT_EQ(2U, event->getPointerCount());
     ASSERT_EQ(1, event->getPointerId(0));
+    ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, event->getToolType(0));
     ASSERT_EQ(2, event->getPointerId(1));
+    ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_STYLUS, event->getToolType(1));
 
     ASSERT_EQ(2U, event->getHistorySize());
 
@@ -534,19 +544,20 @@
     const float ROTATION = ARC * 2;
 
     const size_t pointerCount = 11;
-    int pointerIds[pointerCount];
+    PointerProperties pointerProperties[pointerCount];
     PointerCoords pointerCoords[pointerCount];
     for (size_t i = 0; i < pointerCount; i++) {
         float angle = float(i * ARC * PI_180);
-        pointerIds[i] = i;
+        pointerProperties[i].clear();
+        pointerProperties[i].id = i;
         pointerCoords[i].clear();
         pointerCoords[i].setAxisValue(AMOTION_EVENT_AXIS_X, sinf(angle) * RADIUS + 3);
         pointerCoords[i].setAxisValue(AMOTION_EVENT_AXIS_Y, -cosf(angle) * RADIUS + 2);
         pointerCoords[i].setAxisValue(AMOTION_EVENT_AXIS_ORIENTATION, angle);
     }
     MotionEvent event;
-    event.initialize(0, 0, AMOTION_EVENT_ACTION_MOVE, 0, 0, 0,
-            0, 0, 0, 0, 0, 0, pointerCount, pointerIds, pointerCoords);
+    event.initialize(0, 0, AMOTION_EVENT_ACTION_MOVE, 0, 0, 0, 0,
+            0, 0, 0, 0, 0, 0, pointerCount, pointerProperties, pointerCoords);
     float originalRawX = 0 + 3;
     float originalRawY = -RADIUS + 2;
 
diff --git a/libs/ui/tests/InputPublisherAndConsumer_test.cpp b/libs/ui/tests/InputPublisherAndConsumer_test.cpp
index 6e18a4f..fcc4cad 100644
--- a/libs/ui/tests/InputPublisherAndConsumer_test.cpp
+++ b/libs/ui/tests/InputPublisherAndConsumer_test.cpp
@@ -156,13 +156,19 @@
     const int32_t flags = AMOTION_EVENT_FLAG_WINDOW_IS_OBSCURED;
     const int32_t edgeFlags = AMOTION_EVENT_EDGE_FLAG_TOP;
     const int32_t metaState = AMETA_ALT_LEFT_ON | AMETA_ALT_ON;
+    const int32_t buttonState = AMOTION_EVENT_BUTTON_PRIMARY;
     const float xOffset = -10;
     const float yOffset = -20;
     const float xPrecision = 0.25;
     const float yPrecision = 0.5;
     const nsecs_t downTime = 3;
     const size_t pointerCount = 3;
-    const int32_t pointerIds[pointerCount] = { 2, 0, 1 };
+    PointerProperties pointerProperties[pointerCount];
+    for (size_t i = 0; i < pointerCount; i++) {
+        pointerProperties[i].clear();
+        pointerProperties[i].id = (i + 2) % pointerCount;
+        pointerProperties[i].toolType = AMOTION_EVENT_TOOL_TYPE_FINGER;
+    }
 
     Vector<nsecs_t> sampleEventTimes;
     Vector<PointerCoords> samplePointerCoords;
@@ -186,8 +192,9 @@
     }
 
     status = mPublisher->publishMotionEvent(deviceId, source, action, flags, edgeFlags,
-            metaState, xOffset, yOffset, xPrecision, yPrecision,
-            downTime, sampleEventTimes[0], pointerCount, pointerIds, samplePointerCoords.array());
+            metaState, buttonState, xOffset, yOffset, xPrecision, yPrecision,
+            downTime, sampleEventTimes[0], pointerCount,
+            pointerProperties, samplePointerCoords.array());
     ASSERT_EQ(OK, status)
             << "publisher publishMotionEvent should return OK";
 
@@ -234,6 +241,7 @@
     EXPECT_EQ(flags, motionEvent->getFlags());
     EXPECT_EQ(edgeFlags, motionEvent->getEdgeFlags());
     EXPECT_EQ(metaState, motionEvent->getMetaState());
+    EXPECT_EQ(buttonState, motionEvent->getButtonState());
     EXPECT_EQ(xPrecision, motionEvent->getXPrecision());
     EXPECT_EQ(yPrecision, motionEvent->getYPrecision());
     EXPECT_EQ(downTime, motionEvent->getDownTime());
@@ -243,7 +251,8 @@
 
     for (size_t i = 0; i < pointerCount; i++) {
         SCOPED_TRACE(i);
-        EXPECT_EQ(pointerIds[i], motionEvent->getPointerId(i));
+        EXPECT_EQ(pointerProperties[i].id, motionEvent->getPointerId(i));
+        EXPECT_EQ(pointerProperties[i].toolType, motionEvent->getToolType(i));
     }
 
     for (size_t sampleIndex = 0; sampleIndex < lastSampleIndex; sampleIndex++) {
@@ -352,17 +361,20 @@
     ASSERT_NO_FATAL_FAILURE(Initialize());
 
     const size_t pointerCount = 1;
-    int32_t pointerIds[pointerCount] = { 0 };
+    PointerProperties pointerProperties[pointerCount];
     PointerCoords pointerCoords[pointerCount];
-    pointerCoords[0].clear();
+    for (size_t i = 0; i < pointerCount; i++) {
+        pointerProperties[i].clear();
+        pointerCoords[i].clear();
+    }
 
-    status = mPublisher->publishMotionEvent(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-            pointerCount, pointerIds, pointerCoords);
+    status = mPublisher->publishMotionEvent(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            pointerCount, pointerProperties, pointerCoords);
     ASSERT_EQ(OK, status)
             << "publisher publishMotionEvent should return OK";
 
-    status = mPublisher->publishMotionEvent(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-            pointerCount, pointerIds, pointerCoords);
+    status = mPublisher->publishMotionEvent(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            pointerCount, pointerProperties, pointerCoords);
     ASSERT_EQ(INVALID_OPERATION, status)
             << "publisher publishMotionEvent should return INVALID_OPERATION because ";
                     "the publisher was not reset";
@@ -373,11 +385,11 @@
     ASSERT_NO_FATAL_FAILURE(Initialize());
 
     const size_t pointerCount = 0;
-    int32_t pointerIds[pointerCount];
+    PointerProperties pointerProperties[pointerCount];
     PointerCoords pointerCoords[pointerCount];
 
-    status = mPublisher->publishMotionEvent(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-            pointerCount, pointerIds, pointerCoords);
+    status = mPublisher->publishMotionEvent(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            pointerCount, pointerProperties, pointerCoords);
     ASSERT_EQ(BAD_VALUE, status)
             << "publisher publishMotionEvent should return BAD_VALUE";
 }
@@ -387,11 +399,15 @@
     ASSERT_NO_FATAL_FAILURE(Initialize());
 
     const size_t pointerCount = MAX_POINTERS + 1;
-    int32_t pointerIds[pointerCount];
+    PointerProperties pointerProperties[pointerCount];
     PointerCoords pointerCoords[pointerCount];
+    for (size_t i = 0; i < pointerCount; i++) {
+        pointerProperties[i].clear();
+        pointerCoords[i].clear();
+    }
 
-    status = mPublisher->publishMotionEvent(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-            pointerCount, pointerIds, pointerCoords);
+    status = mPublisher->publishMotionEvent(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            pointerCount, pointerProperties, pointerCoords);
     ASSERT_EQ(BAD_VALUE, status)
             << "publisher publishMotionEvent should return BAD_VALUE";
 }
@@ -432,11 +448,15 @@
     ASSERT_NO_FATAL_FAILURE(Initialize());
 
     const size_t pointerCount = MAX_POINTERS;
-    int32_t pointerIds[pointerCount];
+    PointerProperties pointerProperties[pointerCount];
     PointerCoords pointerCoords[pointerCount];
+    for (size_t i = 0; i < pointerCount; i++) {
+        pointerProperties[i].clear();
+        pointerCoords[i].clear();
+    }
 
     status = mPublisher->publishMotionEvent(0, 0, AMOTION_EVENT_ACTION_DOWN,
-            0, 0, 0, 0, 0, 0, 0, 0, 0, pointerCount, pointerIds, pointerCoords);
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, pointerCount, pointerProperties, pointerCoords);
     ASSERT_EQ(OK, status);
 
     status = mPublisher->appendMotionSample(0, pointerCoords);
@@ -449,11 +469,15 @@
     ASSERT_NO_FATAL_FAILURE(Initialize());
 
     const size_t pointerCount = MAX_POINTERS;
-    int32_t pointerIds[pointerCount];
+    PointerProperties pointerProperties[pointerCount];
     PointerCoords pointerCoords[pointerCount];
+    for (size_t i = 0; i < pointerCount; i++) {
+        pointerProperties[i].clear();
+        pointerCoords[i].clear();
+    }
 
     status = mPublisher->publishMotionEvent(0, 0, AMOTION_EVENT_ACTION_MOVE,
-            0, 0, 0, 0, 0, 0, 0, 0, 0, pointerCount, pointerIds, pointerCoords);
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, pointerCount, pointerProperties, pointerCoords);
     ASSERT_EQ(OK, status);
 
     status = mPublisher->sendDispatchSignal();
@@ -476,11 +500,15 @@
     ASSERT_NO_FATAL_FAILURE(Initialize());
 
     const size_t pointerCount = MAX_POINTERS;
-    int32_t pointerIds[pointerCount];
+    PointerProperties pointerProperties[pointerCount];
     PointerCoords pointerCoords[pointerCount];
+    for (size_t i = 0; i < pointerCount; i++) {
+        pointerProperties[i].clear();
+        pointerCoords[i].clear();
+    }
 
     status = mPublisher->publishMotionEvent(0, 0, AMOTION_EVENT_ACTION_MOVE,
-            0, 0, 0, 0, 0, 0, 0, 0, 0, pointerCount, pointerIds, pointerCoords);
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, pointerCount, pointerProperties, pointerCoords);
     ASSERT_EQ(OK, status);
 
     for (int count = 1;; count++) {
diff --git a/native/android/input.cpp b/native/android/input.cpp
index ed26667..91671c3 100644
--- a/native/android/input.cpp
+++ b/native/android/input.cpp
@@ -92,6 +92,10 @@
     return static_cast<const MotionEvent*>(motion_event)->getMetaState();
 }
 
+int32_t AMotionEvent_getButtonState(const AInputEvent* motion_event) {
+    return static_cast<const MotionEvent*>(motion_event)->getButtonState();
+}
+
 int32_t AMotionEvent_getEdgeFlags(const AInputEvent* motion_event) {
     return reinterpret_cast<const MotionEvent*>(motion_event)->getEdgeFlags();
 }
@@ -128,6 +132,10 @@
     return static_cast<const MotionEvent*>(motion_event)->getPointerId(pointer_index);
 }
 
+int32_t AMotionEvent_getToolType(const AInputEvent* motion_event, size_t pointer_index) {
+    return static_cast<const MotionEvent*>(motion_event)->getToolType(pointer_index);
+}
+
 float AMotionEvent_getRawX(const AInputEvent* motion_event, size_t pointer_index) {
     return static_cast<const MotionEvent*>(motion_event)->getRawX(pointer_index);
 }
diff --git a/native/include/android/input.h b/native/include/android/input.h
index f1738c6..26cac50 100644
--- a/native/include/android/input.h
+++ b/native/include/android/input.h
@@ -372,6 +372,7 @@
     AMOTION_EVENT_AXIS_WHEEL = 21,
     AMOTION_EVENT_AXIS_GAS = 22,
     AMOTION_EVENT_AXIS_BRAKE = 23,
+    AMOTION_EVENT_AXIS_DISTANCE = 24,
     AMOTION_EVENT_AXIS_GENERIC_1 = 32,
     AMOTION_EVENT_AXIS_GENERIC_2 = 33,
     AMOTION_EVENT_AXIS_GENERIC_3 = 34,
@@ -394,6 +395,32 @@
 };
 
 /*
+ * Constants that identify buttons that are associated with motion events.
+ * Refer to the documentation on the MotionEvent class for descriptions of each button.
+ */
+enum {
+    AMOTION_EVENT_BUTTON_PRIMARY = 1 << 0,
+    AMOTION_EVENT_BUTTON_SECONDARY = 1 << 1,
+    AMOTION_EVENT_BUTTON_TERTIARY = 1 << 2,
+    AMOTION_EVENT_BUTTON_BACK = 1 << 3,
+    AMOTION_EVENT_BUTTON_FORWARD = 1 << 4,
+    AMOTION_EVENT_BUTTON_ERASER = 1 << 5,
+};
+
+/*
+ * Constants that identify tool types.
+ * Refer to the documentation on the MotionEvent class for descriptions of each tool type.
+ */
+enum {
+    AMOTION_EVENT_TOOL_TYPE_UNKNOWN = 0,
+    AMOTION_EVENT_TOOL_TYPE_FINGER = 1,
+    AMOTION_EVENT_TOOL_TYPE_STYLUS = 2,
+    AMOTION_EVENT_TOOL_TYPE_MOUSE = 3,
+    AMOTION_EVENT_TOOL_TYPE_INDIRECT_FINGER = 4,
+    AMOTION_EVENT_TOOL_TYPE_INDIRECT_STYLUS = 5,
+};
+
+/*
  * Input sources.
  *
  * Refer to the documentation on android.view.InputDevice for more details about input sources
@@ -417,6 +444,7 @@
     AINPUT_SOURCE_GAMEPAD = 0x00000400 | AINPUT_SOURCE_CLASS_BUTTON,
     AINPUT_SOURCE_TOUCHSCREEN = 0x00001000 | AINPUT_SOURCE_CLASS_POINTER,
     AINPUT_SOURCE_MOUSE = 0x00002000 | AINPUT_SOURCE_CLASS_POINTER,
+    AINPUT_SOURCE_STYLUS = 0x00004000 | AINPUT_SOURCE_CLASS_POINTER,
     AINPUT_SOURCE_TRACKBALL = 0x00010000 | AINPUT_SOURCE_CLASS_NAVIGATION,
     AINPUT_SOURCE_TOUCHPAD = 0x00100000 | AINPUT_SOURCE_CLASS_POSITION,
     AINPUT_SOURCE_JOYSTICK = 0x01000000 | AINPUT_SOURCE_CLASS_JOYSTICK,
@@ -532,6 +560,9 @@
  * event was generated. */
 int32_t AMotionEvent_getMetaState(const AInputEvent* motion_event);
 
+/* Get the button state of all buttons that are pressed. */
+int32_t AMotionEvent_getButtonState(const AInputEvent* motion_event);
+
 /* Get a bitfield indicating which edges, if any, were touched by this motion event.
  * For touch events, clients can use this to determine if the user's finger was
  * touching the edge of the display. */
@@ -572,11 +603,16 @@
 size_t AMotionEvent_getPointerCount(const AInputEvent* motion_event);
 
 /* Get the pointer identifier associated with a particular pointer
- * data index is this event.  The identifier tells you the actual 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. */
 int32_t AMotionEvent_getPointerId(const AInputEvent* motion_event, size_t pointer_index);
 
+/* Get 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. */
+int32_t AMotionEvent_getToolType(const AInputEvent* motion_event, size_t pointer_index);
+
 /* Get the original raw X coordinate of this event.
  * For touch events on the screen, this is the original location of the event
  * on the screen, before it had been adjusted for the containing window
diff --git a/services/input/InputDispatcher.cpp b/services/input/InputDispatcher.cpp
index 5bca7ee..8c535d6 100644
--- a/services/input/InputDispatcher.cpp
+++ b/services/input/InputDispatcher.cpp
@@ -150,7 +150,7 @@
 }
 
 static bool validateMotionEvent(int32_t action, size_t pointerCount,
-        const int32_t* pointerIds) {
+        const PointerProperties* pointerProperties) {
     if (! isValidMotionAction(action, pointerCount)) {
         LOGE("Motion event has invalid action code 0x%x", action);
         return false;
@@ -162,7 +162,7 @@
     }
     BitSet32 pointerIdBits;
     for (size_t i = 0; i < pointerCount; i++) {
-        int32_t id = pointerIds[i];
+        int32_t id = pointerProperties[i].id;
         if (id < 0 || id > MAX_POINTER_ID) {
             LOGE("Motion event has invalid pointer id %d; value must be between 0 and %d",
                     id, MAX_POINTER_ID);
@@ -899,9 +899,10 @@
             MotionSample* nextSample = splitBatchAfterSample->next;
             MotionEntry* nextEntry = mAllocator.obtainMotionEntry(nextSample->eventTime,
                     entry->deviceId, entry->source, entry->policyFlags,
-                    entry->action, entry->flags, entry->metaState, entry->edgeFlags,
+                    entry->action, entry->flags,
+                    entry->metaState, entry->buttonState, entry->edgeFlags,
                     entry->xPrecision, entry->yPrecision, entry->downTime,
-                    entry->pointerCount, entry->pointerIds, nextSample->pointerCoords);
+                    entry->pointerCount, entry->pointerProperties, nextSample->pointerCoords);
             if (nextSample != entry->lastSample) {
                 nextEntry->firstSample.next = nextSample->next;
                 nextEntry->lastSample = entry->lastSample;
@@ -941,11 +942,13 @@
 #if DEBUG_OUTBOUND_EVENT_DETAILS
     LOGD("%seventTime=%lld, deviceId=%d, source=0x%x, policyFlags=0x%x, "
             "action=0x%x, flags=0x%x, "
-            "metaState=0x%x, edgeFlags=0x%x, xPrecision=%f, yPrecision=%f, downTime=%lld",
+            "metaState=0x%x, buttonState=0x%x, "
+            "edgeFlags=0x%x, xPrecision=%f, yPrecision=%f, downTime=%lld",
             prefix,
             entry->eventTime, entry->deviceId, entry->source, entry->policyFlags,
             entry->action, entry->flags,
-            entry->metaState, entry->edgeFlags, entry->xPrecision, entry->yPrecision,
+            entry->metaState, entry->buttonState,
+            entry->edgeFlags, entry->xPrecision, entry->yPrecision,
             entry->downTime);
 
     // Print the most recent sample that we have available, this may change due to batching.
@@ -955,10 +958,12 @@
         sampleCount += 1;
     }
     for (uint32_t i = 0; i < entry->pointerCount; i++) {
-        LOGD("  Pointer %d: id=%d, x=%f, y=%f, pressure=%f, size=%f, "
+        LOGD("  Pointer %d: id=%d, toolType=%d, "
+                "x=%f, y=%f, pressure=%f, size=%f, "
                 "touchMajor=%f, touchMinor=%f, toolMajor=%f, toolMinor=%f, "
                 "orientation=%f",
-                i, entry->pointerIds[i],
+                i, entry->pointerProperties[i].id,
+                entry->pointerProperties[i].toolType,
                 sample->pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_X),
                 sample->pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_Y),
                 sample->pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_PRESSURE),
@@ -1397,7 +1402,7 @@
         // Update the temporary touch state.
         BitSet32 pointerIds;
         if (isSplit) {
-            uint32_t pointerId = entry->pointerIds[pointerIndex];
+            uint32_t pointerId = entry->pointerProperties[pointerIndex].id;
             pointerIds.markBit(pointerId);
         }
         mTempTouchState.addOrUpdateWindow(newTouchedWindow, targetFlags, pointerIds);
@@ -1556,7 +1561,7 @@
                 // One pointer went up.
                 if (isSplit) {
                     int32_t pointerIndex = getMotionEventActionPointerIndex(action);
-                    uint32_t pointerId = entry->pointerIds[pointerIndex];
+                    uint32_t pointerId = entry->pointerProperties[pointerIndex].id;
 
                     for (size_t i = 0; i < mTempTouchState.windows.size(); ) {
                         TouchedWindow& touchedWindow = mTempTouchState.windows.editItemAt(i);
@@ -2010,10 +2015,13 @@
 
         // Publish the motion event and the first motion sample.
         status = connection->inputPublisher.publishMotionEvent(motionEntry->deviceId,
-                motionEntry->source, action, flags, motionEntry->edgeFlags, motionEntry->metaState,
-                xOffset, yOffset, motionEntry->xPrecision, motionEntry->yPrecision,
+                motionEntry->source, action, flags, motionEntry->edgeFlags,
+                motionEntry->metaState, motionEntry->buttonState,
+                xOffset, yOffset,
+                motionEntry->xPrecision, motionEntry->yPrecision,
                 motionEntry->downTime, firstMotionSample->eventTime,
-                motionEntry->pointerCount, motionEntry->pointerIds, usingCoords);
+                motionEntry->pointerCount, motionEntry->pointerProperties,
+                usingCoords);
 
         if (status) {
             LOGE("channel '%s' ~ Could not publish motion event, "
@@ -2027,7 +2035,7 @@
             // Append additional motion samples.
             MotionSample* nextMotionSample = firstMotionSample->next;
             for (; nextMotionSample != NULL; nextMotionSample = nextMotionSample->next) {
-                if ((motionEntry->source & AINPUT_SOURCE_CLASS_POINTER) != 0 && scaleFactor != 1.0f) {
+                if (usingCoords == scaledCoords) {
                     for (size_t i = 0; i < motionEntry->pointerCount; i++) {
                         scaledCoords[i] = nextMotionSample->pointerCoords[i];
                         scaledCoords[i].scale(scaleFactor);
@@ -2305,7 +2313,7 @@
     LOG_ASSERT(pointerIds.value != 0);
 
     uint32_t splitPointerIndexMap[MAX_POINTERS];
-    int32_t splitPointerIds[MAX_POINTERS];
+    PointerProperties splitPointerProperties[MAX_POINTERS];
     PointerCoords splitPointerCoords[MAX_POINTERS];
 
     uint32_t originalPointerCount = originalMotionEntry->pointerCount;
@@ -2313,10 +2321,12 @@
 
     for (uint32_t originalPointerIndex = 0; originalPointerIndex < originalPointerCount;
             originalPointerIndex++) {
-        int32_t pointerId = uint32_t(originalMotionEntry->pointerIds[originalPointerIndex]);
+        const PointerProperties& pointerProperties =
+                originalMotionEntry->pointerProperties[originalPointerIndex];
+        uint32_t pointerId = uint32_t(pointerProperties.id);
         if (pointerIds.hasBit(pointerId)) {
             splitPointerIndexMap[splitPointerCount] = originalPointerIndex;
-            splitPointerIds[splitPointerCount] = pointerId;
+            splitPointerProperties[splitPointerCount].copyFrom(pointerProperties);
             splitPointerCoords[splitPointerCount].copyFrom(
                     originalMotionEntry->firstSample.pointerCoords[originalPointerIndex]);
             splitPointerCount += 1;
@@ -2341,7 +2351,9 @@
     if (maskedAction == AMOTION_EVENT_ACTION_POINTER_DOWN
             || maskedAction == AMOTION_EVENT_ACTION_POINTER_UP) {
         int32_t originalPointerIndex = getMotionEventActionPointerIndex(action);
-        int32_t pointerId = originalMotionEntry->pointerIds[originalPointerIndex];
+        const PointerProperties& pointerProperties =
+                originalMotionEntry->pointerProperties[originalPointerIndex];
+        uint32_t pointerId = uint32_t(pointerProperties.id);
         if (pointerIds.hasBit(pointerId)) {
             if (pointerIds.count() == 1) {
                 // The first/last pointer went down/up.
@@ -2350,7 +2362,7 @@
             } else {
                 // A secondary pointer went down/up.
                 uint32_t splitPointerIndex = 0;
-                while (pointerId != splitPointerIds[splitPointerIndex]) {
+                while (pointerId != uint32_t(splitPointerProperties[splitPointerIndex].id)) {
                     splitPointerIndex += 1;
                 }
                 action = maskedAction | (splitPointerIndex
@@ -2370,11 +2382,12 @@
             action,
             originalMotionEntry->flags,
             originalMotionEntry->metaState,
+            originalMotionEntry->buttonState,
             originalMotionEntry->edgeFlags,
             originalMotionEntry->xPrecision,
             originalMotionEntry->yPrecision,
             originalMotionEntry->downTime,
-            splitPointerCount, splitPointerIds, splitPointerCoords);
+            splitPointerCount, splitPointerProperties, splitPointerCoords);
 
     for (MotionSample* originalMotionSample = originalMotionEntry->firstSample.next;
             originalMotionSample != NULL; originalMotionSample = originalMotionSample->next) {
@@ -2490,20 +2503,25 @@
 }
 
 void InputDispatcher::notifyMotion(nsecs_t eventTime, int32_t deviceId, uint32_t source,
-        uint32_t policyFlags, int32_t action, int32_t flags, int32_t metaState, int32_t edgeFlags,
-        uint32_t pointerCount, const int32_t* pointerIds, const PointerCoords* pointerCoords,
+        uint32_t policyFlags, int32_t action, int32_t flags,
+        int32_t metaState, int32_t buttonState, int32_t edgeFlags,
+        uint32_t pointerCount, const PointerProperties* pointerProperties,
+        const PointerCoords* pointerCoords,
         float xPrecision, float yPrecision, nsecs_t downTime) {
 #if DEBUG_INBOUND_EVENT_DETAILS
     LOGD("notifyMotion - eventTime=%lld, deviceId=%d, source=0x%x, policyFlags=0x%x, "
-            "action=0x%x, flags=0x%x, metaState=0x%x, edgeFlags=0x%x, "
+            "action=0x%x, flags=0x%x, metaState=0x%x, buttonState=0x%x, edgeFlags=0x%x, "
             "xPrecision=%f, yPrecision=%f, downTime=%lld",
-            eventTime, deviceId, source, policyFlags, action, flags, metaState, edgeFlags,
+            eventTime, deviceId, source, policyFlags, action, flags,
+            metaState, buttonState, edgeFlags,
             xPrecision, yPrecision, downTime);
     for (uint32_t i = 0; i < pointerCount; i++) {
-        LOGD("  Pointer %d: id=%d, x=%f, y=%f, pressure=%f, size=%f, "
+        LOGD("  Pointer %d: id=%d, toolType=%d, "
+                "x=%f, y=%f, pressure=%f, size=%f, "
                 "touchMajor=%f, touchMinor=%f, toolMajor=%f, toolMinor=%f, "
                 "orientation=%f",
-                i, pointerIds[i],
+                i, pointerProperties[i].id,
+                pointerProperties[i].toolType,
                 pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_X),
                 pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_Y),
                 pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_PRESSURE),
@@ -2515,7 +2533,7 @@
                 pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_ORIENTATION));
     }
 #endif
-    if (! validateMotionEvent(action, pointerCount, pointerIds)) {
+    if (! validateMotionEvent(action, pointerCount, pointerProperties)) {
         return;
     }
 
@@ -2530,9 +2548,10 @@
             mLock.unlock();
 
             MotionEvent event;
-            event.initialize(deviceId, source, action, flags, edgeFlags, metaState, 0, 0,
+            event.initialize(deviceId, source, action, flags, edgeFlags, metaState,
+                    buttonState, 0, 0,
                     xPrecision, yPrecision, downTime, eventTime,
-                    pointerCount, pointerIds, pointerCoords);
+                    pointerCount, pointerProperties, pointerCoords);
 
             policyFlags |= POLICY_FLAG_FILTERED;
             if (!mPolicy->filterInputEvent(&event, policyFlags)) {
@@ -2564,7 +2583,7 @@
                     continue;
                 }
 
-                if (!motionEntry->canAppendSamples(action, pointerCount, pointerIds)) {
+                if (!motionEntry->canAppendSamples(action, pointerCount, pointerProperties)) {
                     // Last motion event in the queue for this device and source is
                     // not compatible for appending new samples.  Stop here.
                     goto NoBatchingOrStreaming;
@@ -2587,7 +2606,7 @@
                     && mPendingEvent->type == EventEntry::TYPE_MOTION) {
                 MotionEntry* motionEntry = static_cast<MotionEntry*>(mPendingEvent);
                 if (motionEntry->deviceId == deviceId && motionEntry->source == source) {
-                    if (!motionEntry->canAppendSamples(action, pointerCount, pointerIds)) {
+                    if (!motionEntry->canAppendSamples(action, pointerCount, pointerProperties)) {
                         // Pending motion event is for this device and source but it is
                         // not compatible for appending new samples.  Stop here.
                         goto NoBatchingOrStreaming;
@@ -2696,9 +2715,9 @@
 
         // Just enqueue a new motion event.
         MotionEntry* newEntry = mAllocator.obtainMotionEntry(eventTime,
-                deviceId, source, policyFlags, action, flags, metaState, edgeFlags,
+                deviceId, source, policyFlags, action, flags, metaState, buttonState, edgeFlags,
                 xPrecision, yPrecision, downTime,
-                pointerCount, pointerIds, pointerCoords);
+                pointerCount, pointerProperties, pointerCoords);
 
         needWake = enqueueInboundEventLocked(newEntry);
         mLock.unlock();
@@ -2801,8 +2820,8 @@
         const MotionEvent* motionEvent = static_cast<const MotionEvent*>(event);
         int32_t action = motionEvent->getAction();
         size_t pointerCount = motionEvent->getPointerCount();
-        const int32_t* pointerIds = motionEvent->getPointerIds();
-        if (! validateMotionEvent(action, pointerCount, pointerIds)) {
+        const PointerProperties* pointerProperties = motionEvent->getPointerProperties();
+        if (! validateMotionEvent(action, pointerCount, pointerProperties)) {
             return INPUT_EVENT_INJECTION_FAILED;
         }
 
@@ -2817,10 +2836,11 @@
         MotionEntry* motionEntry = mAllocator.obtainMotionEntry(*sampleEventTimes,
                 motionEvent->getDeviceId(), motionEvent->getSource(), policyFlags,
                 action, motionEvent->getFlags(),
-                motionEvent->getMetaState(), motionEvent->getEdgeFlags(),
+                motionEvent->getMetaState(), motionEvent->getButtonState(),
+                motionEvent->getEdgeFlags(),
                 motionEvent->getXPrecision(), motionEvent->getYPrecision(),
                 motionEvent->getDownTime(), uint32_t(pointerCount),
-                pointerIds, samplePointerCoords);
+                pointerProperties, samplePointerCoords);
         for (size_t i = motionEvent->getHistorySize(); i > 0; i--) {
             sampleEventTimes += 1;
             samplePointerCoords += pointerCount;
@@ -3553,167 +3573,186 @@
     sp<Connection> connection = commandEntry->connection;
     bool handled = commandEntry->handled;
 
+    bool skipNext = false;
     if (!connection->outboundQueue.isEmpty()) {
         DispatchEntry* dispatchEntry = connection->outboundQueue.headSentinel.next;
-        if (dispatchEntry->inProgress
-                && dispatchEntry->eventEntry->type == EventEntry::TYPE_KEY) {
-            KeyEntry* keyEntry = static_cast<KeyEntry*>(dispatchEntry->eventEntry);
-            if (!(keyEntry->flags & AKEY_EVENT_FLAG_FALLBACK)) {
-                // Get the fallback key state.
-                // Clear it out after dispatching the UP.
-                int32_t originalKeyCode = keyEntry->keyCode;
-                int32_t fallbackKeyCode = connection->inputState.getFallbackKey(originalKeyCode);
-                if (keyEntry->action == AKEY_EVENT_ACTION_UP) {
-                    connection->inputState.removeFallbackKey(originalKeyCode);
-                }
-
-                if (handled || !dispatchEntry->hasForegroundTarget()) {
-                    // If the application handles the original key for which we previously
-                    // generated a fallback or if the window is not a foreground window,
-                    // then cancel the associated fallback key, if any.
-                    if (fallbackKeyCode != -1) {
-                        if (fallbackKeyCode != AKEYCODE_UNKNOWN) {
-                            CancelationOptions options(CancelationOptions::CANCEL_FALLBACK_EVENTS,
-                                    "application handled the original non-fallback key "
-                                    "or is no longer a foreground target, "
-                                    "canceling previously dispatched fallback key");
-                            options.keyCode = fallbackKeyCode;
-                            synthesizeCancelationEventsForConnectionLocked(connection, options);
-                        }
-                        connection->inputState.removeFallbackKey(originalKeyCode);
-                    }
-                } else {
-                    // If the application did not handle a non-fallback key, first check
-                    // that we are in a good state to perform unhandled key event processing
-                    // Then ask the policy what to do with it.
-                    bool initialDown = keyEntry->action == AKEY_EVENT_ACTION_DOWN
-                            && keyEntry->repeatCount == 0;
-                    if (fallbackKeyCode == -1 && !initialDown) {
-#if DEBUG_OUTBOUND_EVENT_DETAILS
-                        LOGD("Unhandled key event: Skipping unhandled key event processing "
-                                "since this is not an initial down.  "
-                                "keyCode=%d, action=%d, repeatCount=%d",
-                                originalKeyCode, keyEntry->action, keyEntry->repeatCount);
-#endif
-                        goto SkipFallback;
-                    }
-
-                    // Dispatch the unhandled key to the policy.
-#if DEBUG_OUTBOUND_EVENT_DETAILS
-                    LOGD("Unhandled key event: Asking policy to perform fallback action.  "
-                            "keyCode=%d, action=%d, repeatCount=%d",
-                            keyEntry->keyCode, keyEntry->action, keyEntry->repeatCount);
-#endif
-                    KeyEvent event;
-                    initializeKeyEvent(&event, keyEntry);
-
-                    mLock.unlock();
-
-                    bool fallback = mPolicy->dispatchUnhandledKey(connection->inputWindowHandle,
-                            &event, keyEntry->policyFlags, &event);
-
-                    mLock.lock();
-
-                    if (connection->status != Connection::STATUS_NORMAL) {
-                        connection->inputState.removeFallbackKey(originalKeyCode);
-                        return;
-                    }
-
-                    LOG_ASSERT(connection->outboundQueue.headSentinel.next == dispatchEntry);
-
-                    // Latch the fallback keycode for this key on an initial down.
-                    // The fallback keycode cannot change at any other point in the lifecycle.
-                    if (initialDown) {
-                        if (fallback) {
-                            fallbackKeyCode = event.getKeyCode();
-                        } else {
-                            fallbackKeyCode = AKEYCODE_UNKNOWN;
-                        }
-                        connection->inputState.setFallbackKey(originalKeyCode, fallbackKeyCode);
-                    }
-
-                    LOG_ASSERT(fallbackKeyCode != -1);
-
-                    // Cancel the fallback key if the policy decides not to send it anymore.
-                    // We will continue to dispatch the key to the policy but we will no
-                    // longer dispatch a fallback key to the application.
-                    if (fallbackKeyCode != AKEYCODE_UNKNOWN
-                            && (!fallback || fallbackKeyCode != event.getKeyCode())) {
-#if DEBUG_OUTBOUND_EVENT_DETAILS
-                        if (fallback) {
-                            LOGD("Unhandled key event: Policy requested to send key %d"
-                                    "as a fallback for %d, but on the DOWN it had requested "
-                                    "to send %d instead.  Fallback canceled.",
-                                    event.getKeyCode(), originalKeyCode, fallbackKeyCode);
-                        } else {
-                            LOGD("Unhandled key event: Policy did not request fallback for %d,"
-                                    "but on the DOWN it had requested to send %d.  "
-                                    "Fallback canceled.",
-                                    originalKeyCode, fallbackKeyCode);
-                        }
-#endif
-
-                        CancelationOptions options(CancelationOptions::CANCEL_FALLBACK_EVENTS,
-                                "canceling fallback, policy no longer desires it");
-                        options.keyCode = fallbackKeyCode;
-                        synthesizeCancelationEventsForConnectionLocked(connection, options);
-
-                        fallback = false;
-                        fallbackKeyCode = AKEYCODE_UNKNOWN;
-                        if (keyEntry->action != AKEY_EVENT_ACTION_UP) {
-                            connection->inputState.setFallbackKey(originalKeyCode,
-                                    fallbackKeyCode);
-                        }
-                    }
-
-#if DEBUG_OUTBOUND_EVENT_DETAILS
-                    {
-                        String8 msg;
-                        const KeyedVector<int32_t, int32_t>& fallbackKeys =
-                                connection->inputState.getFallbackKeys();
-                        for (size_t i = 0; i < fallbackKeys.size(); i++) {
-                            msg.appendFormat(", %d->%d", fallbackKeys.keyAt(i),
-                                    fallbackKeys.valueAt(i));
-                        }
-                        LOGD("Unhandled key event: %d currently tracked fallback keys%s.",
-                                fallbackKeys.size(), msg.string());
-                    }
-#endif
-
-                    if (fallback) {
-                        // Restart the dispatch cycle using the fallback key.
-                        keyEntry->eventTime = event.getEventTime();
-                        keyEntry->deviceId = event.getDeviceId();
-                        keyEntry->source = event.getSource();
-                        keyEntry->flags = event.getFlags() | AKEY_EVENT_FLAG_FALLBACK;
-                        keyEntry->keyCode = fallbackKeyCode;
-                        keyEntry->scanCode = event.getScanCode();
-                        keyEntry->metaState = event.getMetaState();
-                        keyEntry->repeatCount = event.getRepeatCount();
-                        keyEntry->downTime = event.getDownTime();
-                        keyEntry->syntheticRepeat = false;
-
-#if DEBUG_OUTBOUND_EVENT_DETAILS
-                        LOGD("Unhandled key event: Dispatching fallback key.  "
-                                "originalKeyCode=%d, fallbackKeyCode=%d, fallbackMetaState=%08x",
-                                originalKeyCode, fallbackKeyCode, keyEntry->metaState);
-#endif
-
-                        dispatchEntry->inProgress = false;
-                        startDispatchCycleLocked(now(), connection);
-                        return;
-                    } else {
-#if DEBUG_OUTBOUND_EVENT_DETAILS
-                        LOGD("Unhandled key event: No fallback key.");
-#endif
-                    }
-                }
+        if (dispatchEntry->inProgress) {
+            if (dispatchEntry->eventEntry->type == EventEntry::TYPE_KEY) {
+                KeyEntry* keyEntry = static_cast<KeyEntry*>(dispatchEntry->eventEntry);
+                skipNext = afterKeyEventLockedInterruptible(connection,
+                        dispatchEntry, keyEntry, handled);
+            } else if (dispatchEntry->eventEntry->type == EventEntry::TYPE_MOTION) {
+                MotionEntry* motionEntry = static_cast<MotionEntry*>(dispatchEntry->eventEntry);
+                skipNext = afterMotionEventLockedInterruptible(connection,
+                        dispatchEntry, motionEntry, handled);
             }
         }
     }
 
-SkipFallback:
-    startNextDispatchCycleLocked(now(), connection);
+    if (!skipNext) {
+        startNextDispatchCycleLocked(now(), connection);
+    }
+}
+
+bool InputDispatcher::afterKeyEventLockedInterruptible(const sp<Connection>& connection,
+        DispatchEntry* dispatchEntry, KeyEntry* keyEntry, bool handled) {
+    if (!(keyEntry->flags & AKEY_EVENT_FLAG_FALLBACK)) {
+        // Get the fallback key state.
+        // Clear it out after dispatching the UP.
+        int32_t originalKeyCode = keyEntry->keyCode;
+        int32_t fallbackKeyCode = connection->inputState.getFallbackKey(originalKeyCode);
+        if (keyEntry->action == AKEY_EVENT_ACTION_UP) {
+            connection->inputState.removeFallbackKey(originalKeyCode);
+        }
+
+        if (handled || !dispatchEntry->hasForegroundTarget()) {
+            // If the application handles the original key for which we previously
+            // generated a fallback or if the window is not a foreground window,
+            // then cancel the associated fallback key, if any.
+            if (fallbackKeyCode != -1) {
+                if (fallbackKeyCode != AKEYCODE_UNKNOWN) {
+                    CancelationOptions options(CancelationOptions::CANCEL_FALLBACK_EVENTS,
+                            "application handled the original non-fallback key "
+                            "or is no longer a foreground target, "
+                            "canceling previously dispatched fallback key");
+                    options.keyCode = fallbackKeyCode;
+                    synthesizeCancelationEventsForConnectionLocked(connection, options);
+                }
+                connection->inputState.removeFallbackKey(originalKeyCode);
+            }
+        } else {
+            // If the application did not handle a non-fallback key, first check
+            // that we are in a good state to perform unhandled key event processing
+            // Then ask the policy what to do with it.
+            bool initialDown = keyEntry->action == AKEY_EVENT_ACTION_DOWN
+                    && keyEntry->repeatCount == 0;
+            if (fallbackKeyCode == -1 && !initialDown) {
+#if DEBUG_OUTBOUND_EVENT_DETAILS
+                LOGD("Unhandled key event: Skipping unhandled key event processing "
+                        "since this is not an initial down.  "
+                        "keyCode=%d, action=%d, repeatCount=%d",
+                        originalKeyCode, keyEntry->action, keyEntry->repeatCount);
+#endif
+                return false;
+            }
+
+            // Dispatch the unhandled key to the policy.
+#if DEBUG_OUTBOUND_EVENT_DETAILS
+            LOGD("Unhandled key event: Asking policy to perform fallback action.  "
+                    "keyCode=%d, action=%d, repeatCount=%d",
+                    keyEntry->keyCode, keyEntry->action, keyEntry->repeatCount);
+#endif
+            KeyEvent event;
+            initializeKeyEvent(&event, keyEntry);
+
+            mLock.unlock();
+
+            bool fallback = mPolicy->dispatchUnhandledKey(connection->inputWindowHandle,
+                    &event, keyEntry->policyFlags, &event);
+
+            mLock.lock();
+
+            if (connection->status != Connection::STATUS_NORMAL) {
+                connection->inputState.removeFallbackKey(originalKeyCode);
+                return true; // skip next cycle
+            }
+
+            LOG_ASSERT(connection->outboundQueue.headSentinel.next == dispatchEntry);
+
+            // Latch the fallback keycode for this key on an initial down.
+            // The fallback keycode cannot change at any other point in the lifecycle.
+            if (initialDown) {
+                if (fallback) {
+                    fallbackKeyCode = event.getKeyCode();
+                } else {
+                    fallbackKeyCode = AKEYCODE_UNKNOWN;
+                }
+                connection->inputState.setFallbackKey(originalKeyCode, fallbackKeyCode);
+            }
+
+            LOG_ASSERT(fallbackKeyCode != -1);
+
+            // Cancel the fallback key if the policy decides not to send it anymore.
+            // We will continue to dispatch the key to the policy but we will no
+            // longer dispatch a fallback key to the application.
+            if (fallbackKeyCode != AKEYCODE_UNKNOWN
+                    && (!fallback || fallbackKeyCode != event.getKeyCode())) {
+#if DEBUG_OUTBOUND_EVENT_DETAILS
+                if (fallback) {
+                    LOGD("Unhandled key event: Policy requested to send key %d"
+                            "as a fallback for %d, but on the DOWN it had requested "
+                            "to send %d instead.  Fallback canceled.",
+                            event.getKeyCode(), originalKeyCode, fallbackKeyCode);
+                } else {
+                    LOGD("Unhandled key event: Policy did not request fallback for %d,"
+                            "but on the DOWN it had requested to send %d.  "
+                            "Fallback canceled.",
+                            originalKeyCode, fallbackKeyCode);
+                }
+#endif
+
+                CancelationOptions options(CancelationOptions::CANCEL_FALLBACK_EVENTS,
+                        "canceling fallback, policy no longer desires it");
+                options.keyCode = fallbackKeyCode;
+                synthesizeCancelationEventsForConnectionLocked(connection, options);
+
+                fallback = false;
+                fallbackKeyCode = AKEYCODE_UNKNOWN;
+                if (keyEntry->action != AKEY_EVENT_ACTION_UP) {
+                    connection->inputState.setFallbackKey(originalKeyCode,
+                            fallbackKeyCode);
+                }
+            }
+
+#if DEBUG_OUTBOUND_EVENT_DETAILS
+            {
+                String8 msg;
+                const KeyedVector<int32_t, int32_t>& fallbackKeys =
+                        connection->inputState.getFallbackKeys();
+                for (size_t i = 0; i < fallbackKeys.size(); i++) {
+                    msg.appendFormat(", %d->%d", fallbackKeys.keyAt(i),
+                            fallbackKeys.valueAt(i));
+                }
+                LOGD("Unhandled key event: %d currently tracked fallback keys%s.",
+                        fallbackKeys.size(), msg.string());
+            }
+#endif
+
+            if (fallback) {
+                // Restart the dispatch cycle using the fallback key.
+                keyEntry->eventTime = event.getEventTime();
+                keyEntry->deviceId = event.getDeviceId();
+                keyEntry->source = event.getSource();
+                keyEntry->flags = event.getFlags() | AKEY_EVENT_FLAG_FALLBACK;
+                keyEntry->keyCode = fallbackKeyCode;
+                keyEntry->scanCode = event.getScanCode();
+                keyEntry->metaState = event.getMetaState();
+                keyEntry->repeatCount = event.getRepeatCount();
+                keyEntry->downTime = event.getDownTime();
+                keyEntry->syntheticRepeat = false;
+
+#if DEBUG_OUTBOUND_EVENT_DETAILS
+                LOGD("Unhandled key event: Dispatching fallback key.  "
+                        "originalKeyCode=%d, fallbackKeyCode=%d, fallbackMetaState=%08x",
+                        originalKeyCode, fallbackKeyCode, keyEntry->metaState);
+#endif
+
+                dispatchEntry->inProgress = false;
+                startDispatchCycleLocked(now(), connection);
+                return true; // already started next cycle
+            } else {
+#if DEBUG_OUTBOUND_EVENT_DETAILS
+                LOGD("Unhandled key event: No fallback key.");
+#endif
+            }
+        }
+    }
+    return false;
+}
+
+bool InputDispatcher::afterMotionEventLockedInterruptible(const sp<Connection>& connection,
+        DispatchEntry* dispatchEntry, MotionEntry* motionEntry, bool handled) {
+    return false;
 }
 
 void InputDispatcher::doPokeUserActivityLockedInterruptible(CommandEntry* commandEntry) {
@@ -3817,9 +3856,10 @@
 
 InputDispatcher::MotionEntry* InputDispatcher::Allocator::obtainMotionEntry(nsecs_t eventTime,
         int32_t deviceId, uint32_t source, uint32_t policyFlags, int32_t action, int32_t flags,
-        int32_t metaState, int32_t edgeFlags, float xPrecision, float yPrecision,
+        int32_t metaState, int32_t buttonState,
+        int32_t edgeFlags, float xPrecision, float yPrecision,
         nsecs_t downTime, uint32_t pointerCount,
-        const int32_t* pointerIds, const PointerCoords* pointerCoords) {
+        const PointerProperties* pointerProperties, const PointerCoords* pointerCoords) {
     MotionEntry* entry = mMotionEntryPool.alloc();
     initializeEventEntry(entry, EventEntry::TYPE_MOTION, eventTime, policyFlags);
 
@@ -3829,6 +3869,7 @@
     entry->action = action;
     entry->flags = flags;
     entry->metaState = metaState;
+    entry->buttonState = buttonState;
     entry->edgeFlags = edgeFlags;
     entry->xPrecision = xPrecision;
     entry->yPrecision = yPrecision;
@@ -3839,7 +3880,7 @@
     entry->firstSample.next = NULL;
     entry->lastSample = & entry->firstSample;
     for (uint32_t i = 0; i < pointerCount; i++) {
-        entry->pointerIds[i] = pointerIds[i];
+        entry->pointerProperties[i].copyFrom(pointerProperties[i]);
         entry->firstSample.pointerCoords[i].copyFrom(pointerCoords[i]);
     }
     return entry;
@@ -3977,14 +4018,14 @@
 }
 
 bool InputDispatcher::MotionEntry::canAppendSamples(int32_t action, uint32_t pointerCount,
-        const int32_t* pointerIds) const {
+        const PointerProperties* pointerProperties) const {
     if (this->action != action
             || this->pointerCount != pointerCount
             || this->isInjected()) {
         return false;
     }
     for (uint32_t i = 0; i < pointerCount; i++) {
-        if (this->pointerIds[i] != pointerIds[i]) {
+        if (this->pointerProperties[i] != pointerProperties[i]) {
             return false;
         }
     }
@@ -4114,7 +4155,7 @@
 void InputDispatcher::InputState::MotionMemento::setPointers(const MotionEntry* entry) {
     pointerCount = entry->pointerCount;
     for (uint32_t i = 0; i < entry->pointerCount; i++) {
-        pointerIds[i] = entry->pointerIds[i];
+        pointerProperties[i].copyFrom(entry->pointerProperties[i]);
         pointerCoords[i].copyFrom(entry->lastSample->pointerCoords[i]);
     }
 }
@@ -4143,9 +4184,9 @@
                     memento.hovering
                             ? AMOTION_EVENT_ACTION_HOVER_EXIT
                             : AMOTION_EVENT_ACTION_CANCEL,
-                    0, 0, 0,
+                    0, 0, 0, 0,
                     memento.xPrecision, memento.yPrecision, memento.downTime,
-                    memento.pointerCount, memento.pointerIds, memento.pointerCoords));
+                    memento.pointerCount, memento.pointerProperties, memento.pointerCoords));
             mMotionMementos.removeAt(i);
         } else {
             i += 1;
diff --git a/services/input/InputDispatcher.h b/services/input/InputDispatcher.h
index 96ece32..9ac5b75 100644
--- a/services/input/InputDispatcher.h
+++ b/services/input/InputDispatcher.h
@@ -263,8 +263,9 @@
             int32_t scanCode, int32_t metaState, nsecs_t downTime) = 0;
     virtual void notifyMotion(nsecs_t eventTime, int32_t deviceId, uint32_t source,
             uint32_t policyFlags, int32_t action, int32_t flags,
-            int32_t metaState, int32_t edgeFlags,
-            uint32_t pointerCount, const int32_t* pointerIds, const PointerCoords* pointerCoords,
+            int32_t metaState, int32_t buttonState, int32_t edgeFlags,
+            uint32_t pointerCount, const PointerProperties* pointerProperties,
+            const PointerCoords* pointerCoords,
             float xPrecision, float yPrecision, nsecs_t downTime) = 0;
     virtual void notifySwitch(nsecs_t when,
             int32_t switchCode, int32_t switchValue, uint32_t policyFlags) = 0;
@@ -358,8 +359,9 @@
             int32_t scanCode, int32_t metaState, nsecs_t downTime);
     virtual void notifyMotion(nsecs_t eventTime, int32_t deviceId, uint32_t source,
             uint32_t policyFlags, int32_t action, int32_t flags,
-            int32_t metaState, int32_t edgeFlags,
-            uint32_t pointerCount, const int32_t* pointerIds, const PointerCoords* pointerCoords,
+            int32_t metaState, int32_t buttonState, int32_t edgeFlags,
+            uint32_t pointerCount, const PointerProperties* pointerProperties,
+            const PointerCoords* pointerCoords,
             float xPrecision, float yPrecision, nsecs_t downTime);
     virtual void notifySwitch(nsecs_t when,
             int32_t switchCode, int32_t switchValue, uint32_t policyFlags) ;
@@ -454,12 +456,13 @@
         int32_t action;
         int32_t flags;
         int32_t metaState;
+        int32_t buttonState;
         int32_t edgeFlags;
         float xPrecision;
         float yPrecision;
         nsecs_t downTime;
         uint32_t pointerCount;
-        int32_t pointerIds[MAX_POINTERS];
+        PointerProperties pointerProperties[MAX_POINTERS];
 
         // Linked list of motion samples associated with this motion event.
         MotionSample firstSample;
@@ -469,7 +472,7 @@
 
         // Checks whether we can append samples, assuming the device id and source are the same.
         bool canAppendSamples(int32_t action, uint32_t pointerCount,
-                const int32_t* pointerIds) const;
+                const PointerProperties* pointerProperties) const;
     };
 
     // Tracks the progress of dispatching a particular event to a particular connection.
@@ -602,10 +605,10 @@
                 int32_t repeatCount, nsecs_t downTime);
         MotionEntry* obtainMotionEntry(nsecs_t eventTime,
                 int32_t deviceId, uint32_t source, uint32_t policyFlags, int32_t action,
-                int32_t flags, int32_t metaState, int32_t edgeFlags,
+                int32_t flags, int32_t metaState, int32_t buttonState, int32_t edgeFlags,
                 float xPrecision, float yPrecision,
                 nsecs_t downTime, uint32_t pointerCount,
-                const int32_t* pointerIds, const PointerCoords* pointerCoords);
+                const PointerProperties* pointerProperties, const PointerCoords* pointerCoords);
         DispatchEntry* obtainDispatchEntry(EventEntry* eventEntry,
                 int32_t targetFlags, float xOffset, float yOffset, float scaleFactor);
         CommandEntry* obtainCommandEntry(Command command);
@@ -721,7 +724,7 @@
             float yPrecision;
             nsecs_t downTime;
             uint32_t pointerCount;
-            int32_t pointerIds[MAX_POINTERS];
+            PointerProperties pointerProperties[MAX_POINTERS];
             PointerCoords pointerCoords[MAX_POINTERS];
             bool hovering;
 
@@ -1053,6 +1056,10 @@
     void doNotifyANRLockedInterruptible(CommandEntry* commandEntry);
     void doInterceptKeyBeforeDispatchingLockedInterruptible(CommandEntry* commandEntry);
     void doDispatchCycleFinishedLockedInterruptible(CommandEntry* commandEntry);
+    bool afterKeyEventLockedInterruptible(const sp<Connection>& connection,
+            DispatchEntry* dispatchEntry, KeyEntry* keyEntry, bool handled);
+    bool afterMotionEventLockedInterruptible(const sp<Connection>& connection,
+            DispatchEntry* dispatchEntry, MotionEntry* motionEntry, bool handled);
     void doPokeUserActivityLockedInterruptible(CommandEntry* commandEntry);
     void initializeKeyEvent(KeyEvent* event, const KeyEntry* entry);
 
diff --git a/services/input/InputReader.cpp b/services/input/InputReader.cpp
index 98b3526..6003207 100644
--- a/services/input/InputReader.cpp
+++ b/services/input/InputReader.cpp
@@ -208,23 +208,32 @@
     // Currently all buttons are mapped to the primary button.
     switch (scanCode) {
     case BTN_LEFT:
+        return AMOTION_EVENT_BUTTON_PRIMARY;
     case BTN_RIGHT:
+        return AMOTION_EVENT_BUTTON_SECONDARY;
     case BTN_MIDDLE:
+        return AMOTION_EVENT_BUTTON_TERTIARY;
     case BTN_SIDE:
+        return AMOTION_EVENT_BUTTON_BACK;
     case BTN_EXTRA:
+        return AMOTION_EVENT_BUTTON_FORWARD;
     case BTN_FORWARD:
+        return AMOTION_EVENT_BUTTON_FORWARD;
     case BTN_BACK:
+        return AMOTION_EVENT_BUTTON_BACK;
     case BTN_TASK:
-        return BUTTON_STATE_PRIMARY;
     default:
         return 0;
     }
 }
 
 // Returns true if the pointer should be reported as being down given the specified
-// button states.
-static bool isPointerDown(uint32_t buttonState) {
-    return buttonState & BUTTON_STATE_PRIMARY;
+// button states.  This determines whether the event is reported as a touch event.
+static bool isPointerDown(int32_t buttonState) {
+    return buttonState &
+            (AMOTION_EVENT_BUTTON_PRIMARY | AMOTION_EVENT_BUTTON_SECONDARY
+                    | AMOTION_EVENT_BUTTON_TERTIARY
+                    | AMOTION_EVENT_BUTTON_ERASER);
 }
 
 static int32_t calculateEdgeFlagsUsingPointerBounds(
@@ -273,6 +282,33 @@
     }
 }
 
+static void synthesizeButtonKey(InputReaderContext* context, int32_t action,
+        nsecs_t when, int32_t deviceId, uint32_t source,
+        uint32_t policyFlags, int32_t lastButtonState, int32_t currentButtonState,
+        int32_t buttonState, int32_t keyCode) {
+    if (
+            (action == AKEY_EVENT_ACTION_DOWN
+                    && !(lastButtonState & buttonState)
+                    && (currentButtonState & buttonState))
+            || (action == AKEY_EVENT_ACTION_UP
+                    && (lastButtonState & buttonState)
+                    && !(currentButtonState & buttonState))) {
+        context->getDispatcher()->notifyKey(when, deviceId, source, policyFlags,
+                action, 0, keyCode, 0, context->getGlobalMetaState(), when);
+    }
+}
+
+static void synthesizeButtonKeys(InputReaderContext* context, int32_t action,
+        nsecs_t when, int32_t deviceId, uint32_t source,
+        uint32_t policyFlags, int32_t lastButtonState, int32_t currentButtonState) {
+    synthesizeButtonKey(context, action, when, deviceId, source, policyFlags,
+            lastButtonState, currentButtonState,
+            AMOTION_EVENT_BUTTON_BACK, AKEYCODE_BACK);
+    synthesizeButtonKey(context, action, when, deviceId, source, policyFlags,
+            lastButtonState, currentButtonState,
+            AMOTION_EVENT_BUTTON_FORWARD, AKEYCODE_FORWARD);
+}
+
 
 // --- InputReader ---
 
@@ -1443,7 +1479,7 @@
 
 void CursorInputMapper::reset() {
     for (;;) {
-        uint32_t buttonState;
+        int32_t buttonState;
         { // acquire lock
             AutoMutex _l(mLock);
 
@@ -1469,7 +1505,7 @@
 void CursorInputMapper::process(const RawEvent* rawEvent) {
     switch (rawEvent->type) {
     case EV_KEY: {
-        uint32_t buttonState = getButtonStateForScanCode(rawEvent->scanCode);
+        int32_t buttonState = getButtonStateForScanCode(rawEvent->scanCode);
         if (buttonState) {
             if (rawEvent->value) {
                 mAccumulator.buttonDown = buttonState;
@@ -1527,12 +1563,16 @@
 
     int32_t motionEventAction;
     int32_t motionEventEdgeFlags;
+    int32_t lastButtonState, currentButtonState;
+    PointerProperties pointerProperties;
     PointerCoords pointerCoords;
     nsecs_t downTime;
     float vscroll, hscroll;
     { // acquire lock
         AutoMutex _l(mLock);
 
+        lastButtonState = mLocked.buttonState;
+
         bool down, downChanged;
         bool wasDown = isPointerDown(mLocked.buttonState);
         bool buttonsChanged = fields & Accumulator::FIELD_BUTTONS;
@@ -1555,6 +1595,8 @@
             downChanged = false;
         }
 
+        currentButtonState = mLocked.buttonState;
+
         downTime = mLocked.downTime;
         float deltaX = fields & Accumulator::FIELD_REL_X ? mAccumulator.relX * mXScale : 0.0f;
         float deltaY = fields & Accumulator::FIELD_REL_Y ? mAccumulator.relY * mYScale : 0.0f;
@@ -1598,10 +1640,14 @@
             }
         }
 
-        pointerCoords.clear();
-
         motionEventEdgeFlags = AMOTION_EVENT_EDGE_FLAG_NONE;
 
+        pointerProperties.clear();
+        pointerProperties.id = 0;
+        pointerProperties.toolType = AMOTION_EVENT_TOOL_TYPE_MOUSE;
+
+        pointerCoords.clear();
+
         if (mHaveVWheel && (fields & Accumulator::FIELD_REL_WHEEL)) {
             vscroll = mAccumulator.relWheel;
         } else {
@@ -1656,18 +1702,23 @@
         policyFlags |= POLICY_FLAG_WAKE_DROPPED;
     }
 
+    // Synthesize key down from buttons if needed.
+    synthesizeButtonKeys(getContext(), AKEY_EVENT_ACTION_DOWN, when, getDeviceId(), mSource,
+            policyFlags, lastButtonState, currentButtonState);
+
+    // Send motion event.
     int32_t metaState = mContext->getGlobalMetaState();
-    int32_t pointerId = 0;
     getDispatcher()->notifyMotion(when, getDeviceId(), mSource, policyFlags,
-            motionEventAction, 0, metaState, motionEventEdgeFlags,
-            1, &pointerId, &pointerCoords, mXPrecision, mYPrecision, downTime);
+            motionEventAction, 0, metaState, currentButtonState, motionEventEdgeFlags,
+            1, &pointerProperties, &pointerCoords, mXPrecision, mYPrecision, downTime);
 
     // Send hover move after UP to tell the application that the mouse is hovering now.
     if (motionEventAction == AMOTION_EVENT_ACTION_UP
             && mPointerController != NULL) {
         getDispatcher()->notifyMotion(when, getDeviceId(), mSource, policyFlags,
-                AMOTION_EVENT_ACTION_HOVER_MOVE, 0, metaState, AMOTION_EVENT_EDGE_FLAG_NONE,
-                1, &pointerId, &pointerCoords, mXPrecision, mYPrecision, downTime);
+                AMOTION_EVENT_ACTION_HOVER_MOVE, 0,
+                metaState, currentButtonState, AMOTION_EVENT_EDGE_FLAG_NONE,
+                1, &pointerProperties, &pointerCoords, mXPrecision, mYPrecision, downTime);
     }
 
     // Send scroll events.
@@ -1676,10 +1727,15 @@
         pointerCoords.setAxisValue(AMOTION_EVENT_AXIS_HSCROLL, hscroll);
 
         getDispatcher()->notifyMotion(when, getDeviceId(), mSource, policyFlags,
-                AMOTION_EVENT_ACTION_SCROLL, 0, metaState, AMOTION_EVENT_EDGE_FLAG_NONE,
-                1, &pointerId, &pointerCoords, mXPrecision, mYPrecision, downTime);
+                AMOTION_EVENT_ACTION_SCROLL, 0, metaState, currentButtonState,
+                AMOTION_EVENT_EDGE_FLAG_NONE,
+                1, &pointerProperties, &pointerCoords, mXPrecision, mYPrecision, downTime);
     }
 
+    // Synthesize key up from buttons if needed.
+    synthesizeButtonKeys(getContext(), AKEY_EVENT_ACTION_UP, when, getDeviceId(), mSource,
+            policyFlags, lastButtonState, currentButtonState);
+
     mAccumulator.clear();
 }
 
@@ -2766,6 +2822,11 @@
         }
     }
 
+    // Synthesize key down from buttons if needed.
+    synthesizeButtonKeys(getContext(), AKEY_EVENT_ACTION_DOWN, when, getDeviceId(), mTouchSource,
+            policyFlags, mLastTouch.buttonState, mCurrentTouch.buttonState);
+
+    // Send motion events.
     TouchResult touchResult;
     if (mLastTouch.pointerCount == 0 && mCurrentTouch.pointerCount == 0
             && mLastTouch.buttonState == mCurrentTouch.buttonState) {
@@ -2783,6 +2844,10 @@
         }
     }
 
+    // Synthesize key up from buttons if needed.
+    synthesizeButtonKeys(getContext(), AKEY_EVENT_ACTION_UP, when, getDeviceId(), mTouchSource,
+            policyFlags, mLastTouch.buttonState, mCurrentTouch.buttonState);
+
     // Copy current touch to last touch in preparation for the next cycle.
     // Keep the button state so we can track edge-triggered button state changes.
     if (touchResult == DROP_STROKE) {
@@ -2949,14 +3014,17 @@
     // Dispatch motions.
     BitSet32 currentIdBits = mCurrentTouch.idBits;
     BitSet32 lastIdBits = mLastTouch.idBits;
-    uint32_t metaState = getContext()->getGlobalMetaState();
+    int32_t metaState = getContext()->getGlobalMetaState();
+    int32_t buttonState = mCurrentTouch.buttonState;
 
     if (currentIdBits == lastIdBits) {
         // No pointer id changes so this is a move event.
         // The dispatcher takes care of batching moves so we don't have to deal with that here.
         dispatchMotion(when, policyFlags, mTouchSource,
-                AMOTION_EVENT_ACTION_MOVE, 0, metaState, AMOTION_EVENT_EDGE_FLAG_NONE,
-                mCurrentTouchCoords, mCurrentTouch.idToIndex, currentIdBits, -1,
+                AMOTION_EVENT_ACTION_MOVE, 0, metaState, buttonState,
+                AMOTION_EVENT_EDGE_FLAG_NONE,
+                mCurrentTouchProperties, mCurrentTouchCoords,
+                mCurrentTouch.idToIndex, currentIdBits, -1,
                 xPrecision, yPrecision, mDownTime);
     } else {
         // There may be pointers going up and pointers going down and pointers moving
@@ -2968,10 +3036,13 @@
 
         // Update last coordinates of pointers that have moved so that we observe the new
         // pointer positions at the same time as other pointers that have just gone up.
-        bool moveNeeded = updateMovedPointerCoords(
-                mCurrentTouchCoords, mCurrentTouch.idToIndex,
-                mLastTouchCoords, mLastTouch.idToIndex,
+        bool moveNeeded = updateMovedPointers(
+                mCurrentTouchProperties, mCurrentTouchCoords, mCurrentTouch.idToIndex,
+                mLastTouchProperties, mLastTouchCoords, mLastTouch.idToIndex,
                 moveIdBits);
+        if (buttonState != mLastTouch.buttonState) {
+            moveNeeded = true;
+        }
 
         // Dispatch pointer up events.
         while (!upIdBits.isEmpty()) {
@@ -2979,8 +3050,9 @@
             upIdBits.clearBit(upId);
 
             dispatchMotion(when, policyFlags, mTouchSource,
-                    AMOTION_EVENT_ACTION_POINTER_UP, 0, metaState, 0,
-                    mLastTouchCoords, mLastTouch.idToIndex, dispatchedIdBits, upId,
+                    AMOTION_EVENT_ACTION_POINTER_UP, 0, metaState, buttonState, 0,
+                    mLastTouchProperties, mLastTouchCoords,
+                    mLastTouch.idToIndex, dispatchedIdBits, upId,
                     xPrecision, yPrecision, mDownTime);
             dispatchedIdBits.clearBit(upId);
         }
@@ -2991,8 +3063,9 @@
         if (moveNeeded) {
             LOG_ASSERT(moveIdBits.value == dispatchedIdBits.value);
             dispatchMotion(when, policyFlags, mTouchSource,
-                    AMOTION_EVENT_ACTION_MOVE, 0, metaState, 0,
-                    mCurrentTouchCoords, mCurrentTouch.idToIndex, dispatchedIdBits, -1,
+                    AMOTION_EVENT_ACTION_MOVE, 0, metaState, buttonState, 0,
+                    mCurrentTouchProperties, mCurrentTouchCoords,
+                    mCurrentTouch.idToIndex, dispatchedIdBits, -1,
                     xPrecision, yPrecision, mDownTime);
         }
 
@@ -3011,14 +3084,16 @@
             }
 
             dispatchMotion(when, policyFlags, mTouchSource,
-                    AMOTION_EVENT_ACTION_POINTER_DOWN, 0, metaState, edgeFlags,
-                    mCurrentTouchCoords, mCurrentTouch.idToIndex, dispatchedIdBits, downId,
+                    AMOTION_EVENT_ACTION_POINTER_DOWN, 0, metaState, buttonState, edgeFlags,
+                    mCurrentTouchProperties, mCurrentTouchCoords,
+                    mCurrentTouch.idToIndex, dispatchedIdBits, downId,
                     xPrecision, yPrecision, mDownTime);
         }
     }
 
     // Update state for next time.
     for (uint32_t i = 0; i < currentPointerCount; i++) {
+        mLastTouchProperties[i].copyFrom(mCurrentTouchProperties[i]);
         mLastTouchCoords[i].copyFrom(mCurrentTouchCoords[i]);
     }
 }
@@ -3214,6 +3289,12 @@
         out.setAxisValue(AMOTION_EVENT_AXIS_TOOL_MAJOR, toolMajor);
         out.setAxisValue(AMOTION_EVENT_AXIS_TOOL_MINOR, toolMinor);
         out.setAxisValue(AMOTION_EVENT_AXIS_ORIENTATION, orientation);
+
+        // Write output properties.
+        PointerProperties& properties = mCurrentTouchProperties[i];
+        properties.clear();
+        properties.id = mCurrentTouch.pointers[i].id;
+        properties.toolType = getTouchToolType(mCurrentTouch.pointers[i].isStylus);
     }
 
     // Check edge flags by looking only at the first pointer since the flags are
@@ -3265,7 +3346,8 @@
     }
 
     // Send events!
-    uint32_t metaState = getContext()->getGlobalMetaState();
+    int32_t metaState = getContext()->getGlobalMetaState();
+    int32_t buttonState = mCurrentTouch.buttonState;
 
     // Update last coordinates of pointers that have moved so that we observe the new
     // pointer positions at the same time as other pointers that have just gone up.
@@ -3281,10 +3363,14 @@
             && !mPointerGesture.currentGestureIdBits.isEmpty()) {
         BitSet32 movedGestureIdBits(mPointerGesture.currentGestureIdBits.value
                 & mPointerGesture.lastGestureIdBits.value);
-        moveNeeded = updateMovedPointerCoords(
+        moveNeeded = updateMovedPointers(mPointerGesture.currentGestureProperties,
                 mPointerGesture.currentGestureCoords, mPointerGesture.currentGestureIdToIndex,
+                mPointerGesture.lastGestureProperties,
                 mPointerGesture.lastGestureCoords, mPointerGesture.lastGestureIdToIndex,
                 movedGestureIdBits);
+        if (buttonState != mLastTouch.buttonState) {
+            moveNeeded = true;
+        }
     }
 
     // Send motion events for all pointers that went up or were canceled.
@@ -3292,7 +3378,9 @@
     if (!dispatchedGestureIdBits.isEmpty()) {
         if (cancelPreviousGesture) {
             dispatchMotion(when, policyFlags, mPointerSource,
-                    AMOTION_EVENT_ACTION_CANCEL, 0, metaState, AMOTION_EVENT_EDGE_FLAG_NONE,
+                    AMOTION_EVENT_ACTION_CANCEL, 0, metaState, buttonState,
+                    AMOTION_EVENT_EDGE_FLAG_NONE,
+                    mPointerGesture.lastGestureProperties,
                     mPointerGesture.lastGestureCoords, mPointerGesture.lastGestureIdToIndex,
                     dispatchedGestureIdBits, -1,
                     0, 0, mPointerGesture.downTime);
@@ -3312,7 +3400,8 @@
 
                 dispatchMotion(when, policyFlags, mPointerSource,
                         AMOTION_EVENT_ACTION_POINTER_UP, 0,
-                        metaState, AMOTION_EVENT_EDGE_FLAG_NONE,
+                        metaState, buttonState, AMOTION_EVENT_EDGE_FLAG_NONE,
+                        mPointerGesture.lastGestureProperties,
                         mPointerGesture.lastGestureCoords, mPointerGesture.lastGestureIdToIndex,
                         dispatchedGestureIdBits, id,
                         0, 0, mPointerGesture.downTime);
@@ -3325,7 +3414,8 @@
     // Send motion events for all pointers that moved.
     if (moveNeeded) {
         dispatchMotion(when, policyFlags, mPointerSource,
-                AMOTION_EVENT_ACTION_MOVE, 0, metaState, AMOTION_EVENT_EDGE_FLAG_NONE,
+                AMOTION_EVENT_ACTION_MOVE, 0, metaState, buttonState, AMOTION_EVENT_EDGE_FLAG_NONE,
+                mPointerGesture.currentGestureProperties,
                 mPointerGesture.currentGestureCoords, mPointerGesture.currentGestureIdToIndex,
                 dispatchedGestureIdBits, -1,
                 0, 0, mPointerGesture.downTime);
@@ -3352,7 +3442,8 @@
             }
 
             dispatchMotion(when, policyFlags, mPointerSource,
-                    AMOTION_EVENT_ACTION_POINTER_DOWN, 0, metaState, edgeFlags,
+                    AMOTION_EVENT_ACTION_POINTER_DOWN, 0, metaState, buttonState, edgeFlags,
+                    mPointerGesture.currentGestureProperties,
                     mPointerGesture.currentGestureCoords, mPointerGesture.currentGestureIdToIndex,
                     dispatchedGestureIdBits, id,
                     0, 0, mPointerGesture.downTime);
@@ -3362,7 +3453,9 @@
     // Send motion events for hover.
     if (mPointerGesture.currentGestureMode == PointerGesture::HOVER) {
         dispatchMotion(when, policyFlags, mPointerSource,
-                AMOTION_EVENT_ACTION_HOVER_MOVE, 0, metaState, AMOTION_EVENT_EDGE_FLAG_NONE,
+                AMOTION_EVENT_ACTION_HOVER_MOVE, 0,
+                metaState, buttonState, AMOTION_EVENT_EDGE_FLAG_NONE,
+                mPointerGesture.currentGestureProperties,
                 mPointerGesture.currentGestureCoords, mPointerGesture.currentGestureIdToIndex,
                 mPointerGesture.currentGestureIdBits, -1,
                 0, 0, mPointerGesture.downTime);
@@ -3378,6 +3471,8 @@
             uint32_t id = idBits.firstMarkedBit();
             idBits.clearBit(id);
             uint32_t index = mPointerGesture.currentGestureIdToIndex[id];
+            mPointerGesture.lastGestureProperties[index].copyFrom(
+                    mPointerGesture.currentGestureProperties[index]);
             mPointerGesture.lastGestureCoords[index].copyFrom(
                     mPointerGesture.currentGestureCoords[index]);
             mPointerGesture.lastGestureIdToIndex[id] = index;
@@ -3413,8 +3508,6 @@
                 mPointerGesture.currentGestureMode = PointerGesture::NEUTRAL;
                 mPointerGesture.currentGestureIdBits.clear();
 
-                mPointerController->setButtonState(0);
-
                 if (mParameters.gestureMode == Parameters::GESTURE_MODE_SPOTS) {
                     mPointerGesture.spotGesture = PointerControllerInterface::SPOT_GESTURE_NEUTRAL;
                     mPointerGesture.spotIdBits.clear();
@@ -3509,8 +3602,6 @@
         mPointerGesture.currentGestureMode = PointerGesture::QUIET;
         mPointerGesture.currentGestureIdBits.clear();
 
-        mPointerController->setButtonState(0);
-
         if (mParameters.gestureMode == Parameters::GESTURE_MODE_SPOTS) {
             mPointerGesture.spotGesture = PointerControllerInterface::SPOT_GESTURE_NEUTRAL;
             mPointerGesture.spotIdBits.clear();
@@ -3591,13 +3682,15 @@
         mPointerGesture.currentGestureIdBits.clear();
         mPointerGesture.currentGestureIdBits.markBit(mPointerGesture.activeGestureId);
         mPointerGesture.currentGestureIdToIndex[mPointerGesture.activeGestureId] = 0;
+        mPointerGesture.currentGestureProperties[0].clear();
+        mPointerGesture.currentGestureProperties[0].id = mPointerGesture.activeGestureId;
+        mPointerGesture.currentGestureProperties[0].toolType =
+                AMOTION_EVENT_TOOL_TYPE_INDIRECT_FINGER;
         mPointerGesture.currentGestureCoords[0].clear();
         mPointerGesture.currentGestureCoords[0].setAxisValue(AMOTION_EVENT_AXIS_X, x);
         mPointerGesture.currentGestureCoords[0].setAxisValue(AMOTION_EVENT_AXIS_Y, y);
         mPointerGesture.currentGestureCoords[0].setAxisValue(AMOTION_EVENT_AXIS_PRESSURE, 1.0f);
 
-        mPointerController->setButtonState(BUTTON_STATE_PRIMARY);
-
         if (mParameters.gestureMode == Parameters::GESTURE_MODE_SPOTS) {
             if (activeTouchId >= 0) {
                 // Collapse all spots into one point at the pointer location.
@@ -3648,6 +3741,11 @@
                             mPointerGesture.activeGestureId);
                     mPointerGesture.currentGestureIdToIndex[
                             mPointerGesture.activeGestureId] = 0;
+                    mPointerGesture.currentGestureProperties[0].clear();
+                    mPointerGesture.currentGestureProperties[0].id =
+                            mPointerGesture.activeGestureId;
+                    mPointerGesture.currentGestureProperties[0].toolType =
+                            AMOTION_EVENT_TOOL_TYPE_INDIRECT_FINGER;
                     mPointerGesture.currentGestureCoords[0].clear();
                     mPointerGesture.currentGestureCoords[0].setAxisValue(
                             AMOTION_EVENT_AXIS_X, mPointerGesture.tapX);
@@ -3656,8 +3754,6 @@
                     mPointerGesture.currentGestureCoords[0].setAxisValue(
                             AMOTION_EVENT_AXIS_PRESSURE, 1.0f);
 
-                    mPointerController->setButtonState(BUTTON_STATE_PRIMARY);
-
                     if (mParameters.gestureMode == Parameters::GESTURE_MODE_SPOTS) {
                         mPointerGesture.spotGesture = PointerControllerInterface::SPOT_GESTURE_TAP;
                         mPointerGesture.spotIdBits.clear();
@@ -3691,8 +3787,6 @@
             mPointerGesture.currentGestureMode = PointerGesture::NEUTRAL;
             mPointerGesture.currentGestureIdBits.clear();
 
-            mPointerController->setButtonState(0);
-
             if (mParameters.gestureMode == Parameters::GESTURE_MODE_SPOTS) {
                 mPointerGesture.spotGesture = PointerControllerInterface::SPOT_GESTURE_NEUTRAL;
                 mPointerGesture.spotIdBits.clear();
@@ -3767,14 +3861,16 @@
         mPointerGesture.currentGestureIdBits.clear();
         mPointerGesture.currentGestureIdBits.markBit(mPointerGesture.activeGestureId);
         mPointerGesture.currentGestureIdToIndex[mPointerGesture.activeGestureId] = 0;
+        mPointerGesture.currentGestureProperties[0].clear();
+        mPointerGesture.currentGestureProperties[0].id = mPointerGesture.activeGestureId;
+        mPointerGesture.currentGestureProperties[0].toolType =
+                AMOTION_EVENT_TOOL_TYPE_INDIRECT_FINGER;
         mPointerGesture.currentGestureCoords[0].clear();
         mPointerGesture.currentGestureCoords[0].setAxisValue(AMOTION_EVENT_AXIS_X, x);
         mPointerGesture.currentGestureCoords[0].setAxisValue(AMOTION_EVENT_AXIS_Y, y);
         mPointerGesture.currentGestureCoords[0].setAxisValue(AMOTION_EVENT_AXIS_PRESSURE,
                 down ? 1.0f : 0.0f);
 
-        mPointerController->setButtonState(down ? BUTTON_STATE_PRIMARY : 0);
-
         if (mLastTouch.pointerCount == 0 && mCurrentTouch.pointerCount != 0) {
             mPointerGesture.resetTap();
             mPointerGesture.tapDownTime = when;
@@ -3994,6 +4090,10 @@
             mPointerGesture.currentGestureIdBits.clear();
             mPointerGesture.currentGestureIdBits.markBit(mPointerGesture.activeGestureId);
             mPointerGesture.currentGestureIdToIndex[mPointerGesture.activeGestureId] = 0;
+            mPointerGesture.currentGestureProperties[0].clear();
+            mPointerGesture.currentGestureProperties[0].id = mPointerGesture.activeGestureId;
+            mPointerGesture.currentGestureProperties[0].toolType =
+                    AMOTION_EVENT_TOOL_TYPE_INDIRECT_FINGER;
             mPointerGesture.currentGestureCoords[0].clear();
             mPointerGesture.currentGestureCoords[0].setAxisValue(AMOTION_EVENT_AXIS_X,
                     mPointerGesture.referenceGestureX);
@@ -4001,8 +4101,6 @@
                     mPointerGesture.referenceGestureY);
             mPointerGesture.currentGestureCoords[0].setAxisValue(AMOTION_EVENT_AXIS_PRESSURE, 1.0f);
 
-            mPointerController->setButtonState(BUTTON_STATE_PRIMARY);
-
             if (mParameters.gestureMode == Parameters::GESTURE_MODE_SPOTS) {
                 mPointerGesture.spotGesture = PointerControllerInterface::SPOT_GESTURE_PRESS;
             }
@@ -4018,6 +4116,10 @@
             mPointerGesture.currentGestureIdBits.clear();
             mPointerGesture.currentGestureIdBits.markBit(mPointerGesture.activeGestureId);
             mPointerGesture.currentGestureIdToIndex[mPointerGesture.activeGestureId] = 0;
+            mPointerGesture.currentGestureProperties[0].clear();
+            mPointerGesture.currentGestureProperties[0].id = mPointerGesture.activeGestureId;
+            mPointerGesture.currentGestureProperties[0].toolType =
+                    AMOTION_EVENT_TOOL_TYPE_INDIRECT_FINGER;
             mPointerGesture.currentGestureCoords[0].clear();
             mPointerGesture.currentGestureCoords[0].setAxisValue(AMOTION_EVENT_AXIS_X,
                     mPointerGesture.referenceGestureX);
@@ -4025,8 +4127,6 @@
                     mPointerGesture.referenceGestureY);
             mPointerGesture.currentGestureCoords[0].setAxisValue(AMOTION_EVENT_AXIS_PRESSURE, 1.0f);
 
-            mPointerController->setButtonState(0); // touch is not actually following the pointer
-
             if (mParameters.gestureMode == Parameters::GESTURE_MODE_SPOTS) {
                 mPointerGesture.spotGesture = PointerControllerInterface::SPOT_GESTURE_SWIPE;
             }
@@ -4110,6 +4210,10 @@
                 float y = (mCurrentTouch.pointers[i].y - mPointerGesture.referenceTouchY)
                         * mLocked.pointerGestureYZoomScale + mPointerGesture.referenceGestureY;
 
+                mPointerGesture.currentGestureProperties[i].clear();
+                mPointerGesture.currentGestureProperties[i].id = gestureId;
+                mPointerGesture.currentGestureProperties[i].toolType =
+                        AMOTION_EVENT_TOOL_TYPE_INDIRECT_FINGER;
                 mPointerGesture.currentGestureCoords[i].clear();
                 mPointerGesture.currentGestureCoords[i].setAxisValue(
                         AMOTION_EVENT_AXIS_X, x);
@@ -4128,8 +4232,6 @@
 #endif
             }
 
-            mPointerController->setButtonState(0); // touch is not actually following the pointer
-
             if (mParameters.gestureMode == Parameters::GESTURE_MODE_SPOTS) {
                 mPointerGesture.spotGesture = PointerControllerInterface::SPOT_GESTURE_FREEFORM;
             }
@@ -4159,6 +4261,8 @@
         }
     }
 
+    mPointerController->setButtonState(mCurrentTouch.buttonState);
+
 #if DEBUG_GESTURES
     LOGD("Gestures: finishPreviousGesture=%s, cancelPreviousGesture=%s, "
             "currentGestureMode=%d, currentGestureIdBits=0x%08x, "
@@ -4170,9 +4274,12 @@
         uint32_t id = idBits.firstMarkedBit();
         idBits.clearBit(id);
         uint32_t index = mPointerGesture.currentGestureIdToIndex[id];
+        const PointerProperties& properties = mPointerGesture.currentGestureProperties[index];
         const PointerCoords& coords = mPointerGesture.currentGestureCoords[index];
-        LOGD("  currentGesture[%d]: index=%d, x=%0.3f, y=%0.3f, pressure=%0.3f",
-                id, index, coords.getAxisValue(AMOTION_EVENT_AXIS_X),
+        LOGD("  currentGesture[%d]: index=%d, toolType=%d, "
+                "x=%0.3f, y=%0.3f, pressure=%0.3f",
+                id, index, properties.toolType,
+                coords.getAxisValue(AMOTION_EVENT_AXIS_X),
                 coords.getAxisValue(AMOTION_EVENT_AXIS_Y),
                 coords.getAxisValue(AMOTION_EVENT_AXIS_PRESSURE));
     }
@@ -4180,9 +4287,12 @@
         uint32_t id = idBits.firstMarkedBit();
         idBits.clearBit(id);
         uint32_t index = mPointerGesture.lastGestureIdToIndex[id];
+        const PointerProperties& properties = mPointerGesture.lastGestureProperties[index];
         const PointerCoords& coords = mPointerGesture.lastGestureCoords[index];
-        LOGD("  lastGesture[%d]: index=%d, x=%0.3f, y=%0.3f, pressure=%0.3f",
-                id, index, coords.getAxisValue(AMOTION_EVENT_AXIS_X),
+        LOGD("  lastGesture[%d]: index=%d, toolType=%d, "
+                "x=%0.3f, y=%0.3f, pressure=%0.3f",
+                id, index, properties.toolType,
+                coords.getAxisValue(AMOTION_EVENT_AXIS_X),
                 coords.getAxisValue(AMOTION_EVENT_AXIS_Y),
                 coords.getAxisValue(AMOTION_EVENT_AXIS_PRESSURE));
     }
@@ -4196,17 +4306,18 @@
 }
 
 void TouchInputMapper::dispatchMotion(nsecs_t when, uint32_t policyFlags, uint32_t source,
-        int32_t action, int32_t flags, uint32_t metaState, int32_t edgeFlags,
-        const PointerCoords* coords, const uint32_t* idToIndex, BitSet32 idBits,
+        int32_t action, int32_t flags, int32_t metaState, int32_t buttonState, int32_t edgeFlags,
+        const PointerProperties* properties, const PointerCoords* coords,
+        const uint32_t* idToIndex, BitSet32 idBits,
         int32_t changedId, float xPrecision, float yPrecision, nsecs_t downTime) {
     PointerCoords pointerCoords[MAX_POINTERS];
-    int32_t pointerIds[MAX_POINTERS];
+    PointerProperties pointerProperties[MAX_POINTERS];
     uint32_t pointerCount = 0;
     while (!idBits.isEmpty()) {
         uint32_t id = idBits.firstMarkedBit();
         idBits.clearBit(id);
         uint32_t index = idToIndex[id];
-        pointerIds[pointerCount] = id;
+        pointerProperties[pointerCount].copyFrom(properties[index]);
         pointerCoords[pointerCount].copyFrom(coords[index]);
 
         if (changedId >= 0 && id == uint32_t(changedId)) {
@@ -4233,13 +4344,14 @@
     }
 
     getDispatcher()->notifyMotion(when, getDeviceId(), source, policyFlags,
-            action, flags, metaState, edgeFlags,
-            pointerCount, pointerIds, pointerCoords, xPrecision, yPrecision, downTime);
+            action, flags, metaState, buttonState, edgeFlags,
+            pointerCount, pointerProperties, pointerCoords, xPrecision, yPrecision, downTime);
 }
 
-bool TouchInputMapper::updateMovedPointerCoords(
+bool TouchInputMapper::updateMovedPointers(const PointerProperties* inProperties,
         const PointerCoords* inCoords, const uint32_t* inIdToIndex,
-        PointerCoords* outCoords, const uint32_t* outIdToIndex, BitSet32 idBits) const {
+        PointerProperties* outProperties, PointerCoords* outCoords, const uint32_t* outIdToIndex,
+        BitSet32 idBits) const {
     bool changed = false;
     while (!idBits.isEmpty()) {
         uint32_t id = idBits.firstMarkedBit();
@@ -4247,9 +4359,17 @@
 
         uint32_t inIndex = inIdToIndex[id];
         uint32_t outIndex = outIdToIndex[id];
+
+        const PointerProperties& curInProperties = inProperties[inIndex];
         const PointerCoords& curInCoords = inCoords[inIndex];
+        PointerProperties& curOutProperties = outProperties[outIndex];
         PointerCoords& curOutCoords = outCoords[outIndex];
 
+        if (curInProperties != curOutProperties) {
+            curOutProperties.copyFrom(curInProperties);
+            changed = true;
+        }
+
         if (curInCoords != curOutCoords) {
             curOutCoords.copyFrom(curInCoords);
             changed = true;
@@ -4267,6 +4387,15 @@
     } // release lock
 }
 
+int32_t TouchInputMapper::getTouchToolType(bool isStylus) const {
+    if (mParameters.deviceType == Parameters::DEVICE_TYPE_TOUCH_SCREEN) {
+        return isStylus ? AMOTION_EVENT_TOOL_TYPE_STYLUS : AMOTION_EVENT_TOOL_TYPE_FINGER;
+    } else {
+        return isStylus ? AMOTION_EVENT_TOOL_TYPE_INDIRECT_STYLUS
+                : AMOTION_EVENT_TOOL_TYPE_INDIRECT_FINGER;
+    }
+}
+
 bool TouchInputMapper::isPointInsideSurfaceLocked(int32_t x, int32_t y) {
     return x >= mRawAxes.x.minValue && x <= mRawAxes.x.maxValue
             && y >= mRawAxes.y.minValue && y <= mRawAxes.y.maxValue;
@@ -4927,7 +5056,7 @@
             break;
         default:
             if (mParameters.deviceType == Parameters::DEVICE_TYPE_POINTER) {
-                uint32_t buttonState = getButtonStateForScanCode(rawEvent->scanCode);
+                int32_t buttonState = getButtonStateForScanCode(rawEvent->scanCode);
                 if (buttonState) {
                     if (rawEvent->value) {
                         mAccumulator.buttonDown |= buttonState;
@@ -5015,6 +5144,7 @@
         mCurrentTouch.pointers[0].toolMajor = mToolWidth;
         mCurrentTouch.pointers[0].toolMinor = mToolWidth;
         mCurrentTouch.pointers[0].orientation = 0;
+        mCurrentTouch.pointers[0].isStylus = false; // TODO: Set stylus
         mCurrentTouch.idToIndex[0] = 0;
         mCurrentTouch.idBits.markBit(0);
         mCurrentTouch.buttonState = mButtonState;
@@ -5060,7 +5190,7 @@
     switch (rawEvent->type) {
     case EV_KEY: {
         if (mParameters.deviceType == Parameters::DEVICE_TYPE_POINTER) {
-            uint32_t buttonState = getButtonStateForScanCode(rawEvent->scanCode);
+            int32_t buttonState = getButtonStateForScanCode(rawEvent->scanCode);
             if (buttonState) {
                 if (rawEvent->value) {
                     mAccumulator.buttonDown |= buttonState;
@@ -5221,6 +5351,8 @@
             outPointer.orientation = 0;
         }
 
+        outPointer.isStylus = false; // TODO: Handle stylus
+
         // Assign pointer id using tracking id if available.
         if (havePointerIds) {
             if (fields & Accumulator::FIELD_ABS_MT_TRACKING_ID) {
@@ -5531,6 +5663,12 @@
     }
 
     int32_t metaState = mContext->getGlobalMetaState();
+    int32_t buttonState = 0;
+
+    PointerProperties pointerProperties;
+    pointerProperties.clear();
+    pointerProperties.id = 0;
+    pointerProperties.toolType = AMOTION_EVENT_TOOL_TYPE_UNKNOWN;
 
     PointerCoords pointerCoords;
     pointerCoords.clear();
@@ -5550,10 +5688,9 @@
     // TODO: Use the input device configuration to control this behavior more finely.
     uint32_t policyFlags = 0;
 
-    int32_t pointerId = 0;
     getDispatcher()->notifyMotion(when, getDeviceId(), AINPUT_SOURCE_JOYSTICK, policyFlags,
-            AMOTION_EVENT_ACTION_MOVE, 0, metaState, AMOTION_EVENT_EDGE_FLAG_NONE,
-            1, &pointerId, &pointerCoords, 0, 0, 0);
+            AMOTION_EVENT_ACTION_MOVE, 0, metaState, buttonState, AMOTION_EVENT_EDGE_FLAG_NONE,
+            1, &pointerProperties, &pointerCoords, 0, 0, 0);
 }
 
 bool JoystickInputMapper::filterAxes(bool force) {
diff --git a/services/input/InputReader.h b/services/input/InputReader.h
index 0485617..62ac4b2 100644
--- a/services/input/InputReader.h
+++ b/services/input/InputReader.h
@@ -540,7 +540,7 @@
     sp<PointerControllerInterface> mPointerController;
 
     struct LockedState {
-        uint32_t buttonState;
+        int32_t buttonState;
         nsecs_t downTime;
     } mLocked;
 
@@ -602,6 +602,7 @@
         int32_t toolMajor;
         int32_t toolMinor;
         int32_t orientation;
+        bool isStylus;
 
         inline bool operator== (const PointerData& other) const {
             return id == other.id
@@ -625,7 +626,7 @@
         PointerData pointers[MAX_POINTERS];
         BitSet32 idBits;
         uint32_t idToIndex[MAX_POINTER_ID + 1];
-        uint32_t buttonState;
+        int32_t buttonState;
 
         void copyFrom(const TouchData& other) {
             pointerCount = other.pointerCount;
@@ -774,9 +775,11 @@
 
     // Current and previous touch sample data.
     TouchData mCurrentTouch;
+    PointerProperties mCurrentTouchProperties[MAX_POINTERS];
     PointerCoords mCurrentTouchCoords[MAX_POINTERS];
 
     TouchData mLastTouch;
+    PointerProperties mLastTouchProperties[MAX_POINTERS];
     PointerCoords mLastTouchCoords[MAX_POINTERS];
 
     // The time the primary pointer last went down.
@@ -987,11 +990,13 @@
         Mode currentGestureMode;
         BitSet32 currentGestureIdBits;
         uint32_t currentGestureIdToIndex[MAX_POINTER_ID + 1];
+        PointerProperties currentGestureProperties[MAX_POINTERS];
         PointerCoords currentGestureCoords[MAX_POINTERS];
 
         Mode lastGestureMode;
         BitSet32 lastGestureIdBits;
         uint32_t lastGestureIdToIndex[MAX_POINTER_ID + 1];
+        PointerProperties lastGestureProperties[MAX_POINTERS];
         PointerCoords lastGestureCoords[MAX_POINTERS];
 
         // Pointer coords and ids for the current spots.
@@ -1068,17 +1073,22 @@
     // method will take care of setting the index and transmuting the action to DOWN or UP
     // it is the first / last pointer to go down / up.
     void dispatchMotion(nsecs_t when, uint32_t policyFlags, uint32_t source,
-            int32_t action, int32_t flags, uint32_t metaState, int32_t edgeFlags,
-            const PointerCoords* coords, const uint32_t* idToIndex, BitSet32 idBits,
+            int32_t action, int32_t flags, int32_t metaState, int32_t buttonState,
+            int32_t edgeFlags,
+            const PointerProperties* properties, const PointerCoords* coords,
+            const uint32_t* idToIndex, BitSet32 idBits,
             int32_t changedId, float xPrecision, float yPrecision, nsecs_t downTime);
 
-    // Updates pointer coords for pointers with specified ids that have moved.
+    // Updates pointer coords and properties for pointers with specified ids that have moved.
     // Returns true if any of them changed.
-    bool updateMovedPointerCoords(const PointerCoords* inCoords, const uint32_t* inIdToIndex,
-            PointerCoords* outCoords, const uint32_t* outIdToIndex, BitSet32 idBits) const;
+    bool updateMovedPointers(const PointerProperties* inProperties,
+            const PointerCoords* inCoords, const uint32_t* inIdToIndex,
+            PointerProperties* outProperties, PointerCoords* outCoords,
+            const uint32_t* outIdToIndex, BitSet32 idBits) const;
 
     void suppressSwipeOntoVirtualKeys(nsecs_t when);
 
+    int32_t getTouchToolType(bool isStylus) const;
     bool isPointInsideSurfaceLocked(int32_t x, int32_t y);
     const VirtualKey* findVirtualKeyHitLocked(int32_t x, int32_t y);
 
@@ -1134,7 +1144,7 @@
     int32_t mY;
     int32_t mPressure;
     int32_t mToolWidth;
-    uint32_t mButtonState;
+    int32_t mButtonState;
 
     void initialize();
 
@@ -1198,7 +1208,7 @@
         }
     } mAccumulator;
 
-    uint32_t mButtonState;
+    int32_t mButtonState;
 
     void initialize();
 
diff --git a/services/input/PointerController.cpp b/services/input/PointerController.cpp
index ffef720..b87c98d 100644
--- a/services/input/PointerController.cpp
+++ b/services/input/PointerController.cpp
@@ -137,7 +137,7 @@
     setPositionLocked(mLocked.pointerX + deltaX, mLocked.pointerY + deltaY);
 }
 
-void PointerController::setButtonState(uint32_t buttonState) {
+void PointerController::setButtonState(int32_t buttonState) {
 #if DEBUG_POINTER_UPDATES
     LOGD("Set button state 0x%08x", buttonState);
 #endif
@@ -148,7 +148,7 @@
     }
 }
 
-uint32_t PointerController::getButtonState() const {
+int32_t PointerController::getButtonState() const {
     AutoMutex _l(mLock);
 
     return mLocked.buttonState;
diff --git a/services/input/PointerController.h b/services/input/PointerController.h
index b9184ac..c7435ee 100644
--- a/services/input/PointerController.h
+++ b/services/input/PointerController.h
@@ -53,10 +53,10 @@
     virtual void move(float deltaX, float deltaY) = 0;
 
     /* Sets a mask that indicates which buttons are pressed. */
-    virtual void setButtonState(uint32_t buttonState) = 0;
+    virtual void setButtonState(int32_t buttonState) = 0;
 
     /* Gets a mask that indicates which buttons are pressed. */
-    virtual uint32_t getButtonState() const = 0;
+    virtual int32_t getButtonState() const = 0;
 
     /* Sets the absolute location of the pointer. */
     virtual void setPosition(float x, float y) = 0;
@@ -183,8 +183,8 @@
     virtual bool getBounds(float* outMinX, float* outMinY,
             float* outMaxX, float* outMaxY) const;
     virtual void move(float deltaX, float deltaY);
-    virtual void setButtonState(uint32_t buttonState);
-    virtual uint32_t getButtonState() const;
+    virtual void setButtonState(int32_t buttonState);
+    virtual int32_t getButtonState() const;
     virtual void setPosition(float x, float y);
     virtual void getPosition(float* outX, float* outY) const;
     virtual void fade();
@@ -258,7 +258,7 @@
         SpriteIcon pointerIcon;
         bool pointerIconChanged;
 
-        uint32_t buttonState;
+        int32_t buttonState;
 
         Vector<Spot*> spots;
         Vector<sp<Sprite> > recycledSprites;
diff --git a/services/input/tests/InputDispatcher_test.cpp b/services/input/tests/InputDispatcher_test.cpp
index 3650da0..3db3473 100644
--- a/services/input/tests/InputDispatcher_test.cpp
+++ b/services/input/tests/InputDispatcher_test.cpp
@@ -142,17 +142,19 @@
 
 TEST_F(InputDispatcherTest, InjectInputEvent_ValidatesMotionEvents) {
     MotionEvent event;
-    int32_t pointerIds[MAX_POINTERS + 1];
+    PointerProperties pointerProperties[MAX_POINTERS + 1];
     PointerCoords pointerCoords[MAX_POINTERS + 1];
     for (int i = 0; i <= MAX_POINTERS; i++) {
-        pointerIds[i] = i;
+        pointerProperties[i].clear();
+        pointerProperties[i].id = i;
+        pointerCoords[i].clear();
     }
 
     // Rejects undefined motion actions.
     event.initialize(DEVICE_ID, AINPUT_SOURCE_TOUCHSCREEN,
-            /*action*/ -1, 0, 0, AMETA_NONE, 0, 0, 0, 0,
+            /*action*/ -1, 0, 0, AMETA_NONE, 0, 0, 0, 0, 0,
             ARBITRARY_TIME, ARBITRARY_TIME,
-            /*pointerCount*/ 1, pointerIds, pointerCoords);
+            /*pointerCount*/ 1, pointerProperties, pointerCoords);
     ASSERT_EQ(INPUT_EVENT_INJECTION_FAILED, mDispatcher->injectInputEvent(&event,
             INJECTOR_PID, INJECTOR_UID, INPUT_EVENT_INJECTION_SYNC_NONE, 0, 0))
             << "Should reject motion events with undefined action.";
@@ -160,18 +162,18 @@
     // Rejects pointer down with invalid index.
     event.initialize(DEVICE_ID, AINPUT_SOURCE_TOUCHSCREEN,
             AMOTION_EVENT_ACTION_POINTER_DOWN | (1 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT),
-            0, 0, AMETA_NONE, 0, 0, 0, 0,
+            0, 0, AMETA_NONE, 0, 0, 0, 0, 0,
             ARBITRARY_TIME, ARBITRARY_TIME,
-            /*pointerCount*/ 1, pointerIds, pointerCoords);
+            /*pointerCount*/ 1, pointerProperties, pointerCoords);
     ASSERT_EQ(INPUT_EVENT_INJECTION_FAILED, mDispatcher->injectInputEvent(&event,
             INJECTOR_PID, INJECTOR_UID, INPUT_EVENT_INJECTION_SYNC_NONE, 0, 0))
             << "Should reject motion events with pointer down index too large.";
 
     event.initialize(DEVICE_ID, AINPUT_SOURCE_TOUCHSCREEN,
             AMOTION_EVENT_ACTION_POINTER_DOWN | (-1 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT),
-            0, 0, AMETA_NONE, 0, 0, 0, 0,
+            0, 0, AMETA_NONE, 0, 0, 0, 0, 0,
             ARBITRARY_TIME, ARBITRARY_TIME,
-            /*pointerCount*/ 1, pointerIds, pointerCoords);
+            /*pointerCount*/ 1, pointerProperties, pointerCoords);
     ASSERT_EQ(INPUT_EVENT_INJECTION_FAILED, mDispatcher->injectInputEvent(&event,
             INJECTOR_PID, INJECTOR_UID, INPUT_EVENT_INJECTION_SYNC_NONE, 0, 0))
             << "Should reject motion events with pointer down index too small.";
@@ -179,65 +181,65 @@
     // Rejects pointer up with invalid index.
     event.initialize(DEVICE_ID, AINPUT_SOURCE_TOUCHSCREEN,
             AMOTION_EVENT_ACTION_POINTER_UP | (1 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT),
-            0, 0, AMETA_NONE, 0, 0, 0, 0,
+            0, 0, AMETA_NONE, 0, 0, 0, 0, 0,
             ARBITRARY_TIME, ARBITRARY_TIME,
-            /*pointerCount*/ 1, pointerIds, pointerCoords);
+            /*pointerCount*/ 1, pointerProperties, pointerCoords);
     ASSERT_EQ(INPUT_EVENT_INJECTION_FAILED, mDispatcher->injectInputEvent(&event,
             INJECTOR_PID, INJECTOR_UID, INPUT_EVENT_INJECTION_SYNC_NONE, 0, 0))
             << "Should reject motion events with pointer up index too large.";
 
     event.initialize(DEVICE_ID, AINPUT_SOURCE_TOUCHSCREEN,
             AMOTION_EVENT_ACTION_POINTER_UP | (-1 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT),
-            0, 0, AMETA_NONE, 0, 0, 0, 0,
+            0, 0, AMETA_NONE, 0, 0, 0, 0, 0,
             ARBITRARY_TIME, ARBITRARY_TIME,
-            /*pointerCount*/ 1, pointerIds, pointerCoords);
+            /*pointerCount*/ 1, pointerProperties, pointerCoords);
     ASSERT_EQ(INPUT_EVENT_INJECTION_FAILED, mDispatcher->injectInputEvent(&event,
             INJECTOR_PID, INJECTOR_UID, INPUT_EVENT_INJECTION_SYNC_NONE, 0, 0))
             << "Should reject motion events with pointer up index too small.";
 
     // Rejects motion events with invalid number of pointers.
     event.initialize(DEVICE_ID, AINPUT_SOURCE_TOUCHSCREEN,
-            AMOTION_EVENT_ACTION_DOWN, 0, 0, AMETA_NONE, 0, 0, 0, 0,
+            AMOTION_EVENT_ACTION_DOWN, 0, 0, AMETA_NONE, 0, 0, 0, 0, 0,
             ARBITRARY_TIME, ARBITRARY_TIME,
-            /*pointerCount*/ 0, pointerIds, pointerCoords);
+            /*pointerCount*/ 0, pointerProperties, pointerCoords);
     ASSERT_EQ(INPUT_EVENT_INJECTION_FAILED, mDispatcher->injectInputEvent(&event,
             INJECTOR_PID, INJECTOR_UID, INPUT_EVENT_INJECTION_SYNC_NONE, 0, 0))
             << "Should reject motion events with 0 pointers.";
 
     event.initialize(DEVICE_ID, AINPUT_SOURCE_TOUCHSCREEN,
-            AMOTION_EVENT_ACTION_DOWN, 0, 0, AMETA_NONE, 0, 0, 0, 0,
+            AMOTION_EVENT_ACTION_DOWN, 0, 0, AMETA_NONE, 0, 0, 0, 0, 0,
             ARBITRARY_TIME, ARBITRARY_TIME,
-            /*pointerCount*/ MAX_POINTERS + 1, pointerIds, pointerCoords);
+            /*pointerCount*/ MAX_POINTERS + 1, pointerProperties, pointerCoords);
     ASSERT_EQ(INPUT_EVENT_INJECTION_FAILED, mDispatcher->injectInputEvent(&event,
             INJECTOR_PID, INJECTOR_UID, INPUT_EVENT_INJECTION_SYNC_NONE, 0, 0))
             << "Should reject motion events with more than MAX_POINTERS pointers.";
 
     // Rejects motion events with invalid pointer ids.
-    pointerIds[0] = -1;
+    pointerProperties[0].id = -1;
     event.initialize(DEVICE_ID, AINPUT_SOURCE_TOUCHSCREEN,
-            AMOTION_EVENT_ACTION_DOWN, 0, 0, AMETA_NONE, 0, 0, 0, 0,
+            AMOTION_EVENT_ACTION_DOWN, 0, 0, AMETA_NONE, 0, 0, 0, 0, 0,
             ARBITRARY_TIME, ARBITRARY_TIME,
-            /*pointerCount*/ 1, pointerIds, pointerCoords);
+            /*pointerCount*/ 1, pointerProperties, pointerCoords);
     ASSERT_EQ(INPUT_EVENT_INJECTION_FAILED, mDispatcher->injectInputEvent(&event,
             INJECTOR_PID, INJECTOR_UID, INPUT_EVENT_INJECTION_SYNC_NONE, 0, 0))
             << "Should reject motion events with pointer ids less than 0.";
 
-    pointerIds[0] = MAX_POINTER_ID + 1;
+    pointerProperties[0].id = MAX_POINTER_ID + 1;
     event.initialize(DEVICE_ID, AINPUT_SOURCE_TOUCHSCREEN,
-            AMOTION_EVENT_ACTION_DOWN, 0, 0, AMETA_NONE, 0, 0, 0, 0,
+            AMOTION_EVENT_ACTION_DOWN, 0, 0, AMETA_NONE, 0, 0, 0, 0, 0,
             ARBITRARY_TIME, ARBITRARY_TIME,
-            /*pointerCount*/ 1, pointerIds, pointerCoords);
+            /*pointerCount*/ 1, pointerProperties, pointerCoords);
     ASSERT_EQ(INPUT_EVENT_INJECTION_FAILED, mDispatcher->injectInputEvent(&event,
             INJECTOR_PID, INJECTOR_UID, INPUT_EVENT_INJECTION_SYNC_NONE, 0, 0))
             << "Should reject motion events with pointer ids greater than MAX_POINTER_ID.";
 
     // Rejects motion events with duplicate pointer ids.
-    pointerIds[0] = 1;
-    pointerIds[1] = 1;
+    pointerProperties[0].id = 1;
+    pointerProperties[1].id = 1;
     event.initialize(DEVICE_ID, AINPUT_SOURCE_TOUCHSCREEN,
-            AMOTION_EVENT_ACTION_DOWN, 0, 0, AMETA_NONE, 0, 0, 0, 0,
+            AMOTION_EVENT_ACTION_DOWN, 0, 0, AMETA_NONE, 0, 0, 0, 0, 0,
             ARBITRARY_TIME, ARBITRARY_TIME,
-            /*pointerCount*/ 2, pointerIds, pointerCoords);
+            /*pointerCount*/ 2, pointerProperties, pointerCoords);
     ASSERT_EQ(INPUT_EVENT_INJECTION_FAILED, mDispatcher->injectInputEvent(&event,
             INJECTOR_PID, INJECTOR_UID, INPUT_EVENT_INJECTION_SYNC_NONE, 0, 0))
             << "Should reject motion events with duplicate pointer ids.";
diff --git a/services/input/tests/InputReader_test.cpp b/services/input/tests/InputReader_test.cpp
index 54bb9d7..f5d7ae8 100644
--- a/services/input/tests/InputReader_test.cpp
+++ b/services/input/tests/InputReader_test.cpp
@@ -77,10 +77,10 @@
     virtual void move(float deltaX, float deltaY) {
     }
 
-    virtual void setButtonState(uint32_t buttonState) {
+    virtual void setButtonState(int32_t buttonState) {
     }
 
-    virtual uint32_t getButtonState() const {
+    virtual int32_t getButtonState() const {
         return 0;
     }
 
@@ -236,9 +236,10 @@
         int32_t action;
         int32_t flags;
         int32_t metaState;
+        int32_t buttonState;
         int32_t edgeFlags;
         uint32_t pointerCount;
-        Vector<int32_t> pointerIds;
+        Vector<PointerProperties> pointerProperties;
         Vector<PointerCoords> pointerCoords;
         float xPrecision;
         float yPrecision;
@@ -337,8 +338,9 @@
 
     virtual void notifyMotion(nsecs_t eventTime, int32_t deviceId, uint32_t source,
             uint32_t policyFlags, int32_t action, int32_t flags,
-            int32_t metaState, int32_t edgeFlags,
-            uint32_t pointerCount, const int32_t* pointerIds, const PointerCoords* pointerCoords,
+            int32_t metaState, int32_t buttonState, int32_t edgeFlags,
+            uint32_t pointerCount, const PointerProperties* pointerProperties,
+            const PointerCoords* pointerCoords,
             float xPrecision, float yPrecision, nsecs_t downTime) {
         NotifyMotionArgs args;
         args.eventTime = eventTime;
@@ -348,10 +350,11 @@
         args.action = action;
         args.flags = flags;
         args.metaState = metaState;
+        args.buttonState = buttonState;
         args.edgeFlags = edgeFlags;
         args.pointerCount = pointerCount;
-        args.pointerIds.clear();
-        args.pointerIds.appendArray(pointerIds, pointerCount);
+        args.pointerProperties.clear();
+        args.pointerProperties.appendArray(pointerProperties, pointerCount);
         args.pointerCoords.clear();
         args.pointerCoords.appendArray(pointerCoords, pointerCount);
         args.xPrecision = xPrecision;
@@ -2104,9 +2107,11 @@
     ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, args.action);
     ASSERT_EQ(0, args.flags);
     ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, args.metaState);
+    ASSERT_EQ(AMOTION_EVENT_BUTTON_PRIMARY, args.buttonState);
     ASSERT_EQ(0, args.edgeFlags);
     ASSERT_EQ(uint32_t(1), args.pointerCount);
-    ASSERT_EQ(0, args.pointerIds[0]);
+    ASSERT_EQ(0, args.pointerProperties[0].id);
+    ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_MOUSE, args.pointerProperties[0].toolType);
     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0],
             0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f));
     ASSERT_EQ(TRACKBALL_MOVEMENT_THRESHOLD, args.xPrecision);
@@ -2123,9 +2128,11 @@
     ASSERT_EQ(AMOTION_EVENT_ACTION_UP, args.action);
     ASSERT_EQ(0, args.flags);
     ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, args.metaState);
+    ASSERT_EQ(0, args.buttonState);
     ASSERT_EQ(0, args.edgeFlags);
     ASSERT_EQ(uint32_t(1), args.pointerCount);
-    ASSERT_EQ(0, args.pointerIds[0]);
+    ASSERT_EQ(0, args.pointerProperties[0].id);
+    ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_MOUSE, args.pointerProperties[0].toolType);
     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0],
             0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f));
     ASSERT_EQ(TRACKBALL_MOVEMENT_THRESHOLD, args.xPrecision);
@@ -2756,9 +2763,11 @@
     ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, motionArgs.action);
     ASSERT_EQ(0, motionArgs.flags);
     ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
+    ASSERT_EQ(0, motionArgs.buttonState);
     ASSERT_EQ(0, motionArgs.edgeFlags);
     ASSERT_EQ(size_t(1), motionArgs.pointerCount);
-    ASSERT_EQ(0, motionArgs.pointerIds[0]);
+    ASSERT_EQ(0, motionArgs.pointerProperties[0].id);
+    ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
             toDisplayX(x), toDisplayY(y), 1, 0, 0, 0, 0, 0, 0));
     ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON);
@@ -2778,9 +2787,11 @@
     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
     ASSERT_EQ(0, motionArgs.flags);
     ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
+    ASSERT_EQ(0, motionArgs.buttonState);
     ASSERT_EQ(0, motionArgs.edgeFlags);
     ASSERT_EQ(size_t(1), motionArgs.pointerCount);
-    ASSERT_EQ(0, motionArgs.pointerIds[0]);
+    ASSERT_EQ(0, motionArgs.pointerProperties[0].id);
+    ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
             toDisplayX(x), toDisplayY(y), 1, 0, 0, 0, 0, 0, 0));
     ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON);
@@ -2799,9 +2810,11 @@
     ASSERT_EQ(AMOTION_EVENT_ACTION_UP, motionArgs.action);
     ASSERT_EQ(0, motionArgs.flags);
     ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
+    ASSERT_EQ(0, motionArgs.buttonState);
     ASSERT_EQ(0, motionArgs.edgeFlags);
     ASSERT_EQ(size_t(1), motionArgs.pointerCount);
-    ASSERT_EQ(0, motionArgs.pointerIds[0]);
+    ASSERT_EQ(0, motionArgs.pointerProperties[0].id);
+    ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
             toDisplayX(x), toDisplayY(y), 1, 0, 0, 0, 0, 0, 0));
     ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON);
@@ -2847,9 +2860,11 @@
     ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, motionArgs.action);
     ASSERT_EQ(0, motionArgs.flags);
     ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
+    ASSERT_EQ(0, motionArgs.buttonState);
     ASSERT_EQ(0, motionArgs.edgeFlags);
     ASSERT_EQ(size_t(1), motionArgs.pointerCount);
-    ASSERT_EQ(0, motionArgs.pointerIds[0]);
+    ASSERT_EQ(0, motionArgs.pointerProperties[0].id);
+    ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
             toDisplayX(x), toDisplayY(y), 1, 0, 0, 0, 0, 0, 0));
     ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON);
@@ -2868,9 +2883,11 @@
     ASSERT_EQ(AMOTION_EVENT_ACTION_UP, motionArgs.action);
     ASSERT_EQ(0, motionArgs.flags);
     ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
+    ASSERT_EQ(0, motionArgs.buttonState);
     ASSERT_EQ(0, motionArgs.edgeFlags);
     ASSERT_EQ(size_t(1), motionArgs.pointerCount);
-    ASSERT_EQ(0, motionArgs.pointerIds[0]);
+    ASSERT_EQ(0, motionArgs.pointerProperties[0].id);
+    ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
             toDisplayX(x), toDisplayY(y), 1, 0, 0, 0, 0, 0, 0));
     ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON);
@@ -2908,9 +2925,11 @@
     ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, motionArgs.action);
     ASSERT_EQ(0, motionArgs.flags);
     ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
+    ASSERT_EQ(0, motionArgs.buttonState);
     ASSERT_EQ(0, motionArgs.edgeFlags);
     ASSERT_EQ(size_t(1), motionArgs.pointerCount);
-    ASSERT_EQ(0, motionArgs.pointerIds[0]);
+    ASSERT_EQ(0, motionArgs.pointerProperties[0].id);
+    ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
             toDisplayX(x), toDisplayY(y), 1, 0, 0, 0, 0, 0, 0));
     ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON);
@@ -2931,9 +2950,11 @@
     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
     ASSERT_EQ(0, motionArgs.flags);
     ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
+    ASSERT_EQ(0, motionArgs.buttonState);
     ASSERT_EQ(0, motionArgs.edgeFlags);
     ASSERT_EQ(size_t(1), motionArgs.pointerCount);
-    ASSERT_EQ(0, motionArgs.pointerIds[0]);
+    ASSERT_EQ(0, motionArgs.pointerProperties[0].id);
+    ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
             toDisplayX(x), toDisplayY(y), 1, 0, 0, 0, 0, 0, 0));
     ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON);
@@ -2952,9 +2973,11 @@
     ASSERT_EQ(AMOTION_EVENT_ACTION_UP, motionArgs.action);
     ASSERT_EQ(0, motionArgs.flags);
     ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
+    ASSERT_EQ(0, motionArgs.buttonState);
     ASSERT_EQ(0, motionArgs.edgeFlags);
     ASSERT_EQ(size_t(1), motionArgs.pointerCount);
-    ASSERT_EQ(0, motionArgs.pointerIds[0]);
+    ASSERT_EQ(0, motionArgs.pointerProperties[0].id);
+    ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
             toDisplayX(x), toDisplayY(y), 1, 0, 0, 0, 0, 0, 0));
     ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON);
@@ -3215,9 +3238,11 @@
     ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, motionArgs.action);
     ASSERT_EQ(0, motionArgs.flags);
     ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
+    ASSERT_EQ(0, motionArgs.buttonState);
     ASSERT_EQ(0, motionArgs.edgeFlags);
     ASSERT_EQ(size_t(1), motionArgs.pointerCount);
-    ASSERT_EQ(0, motionArgs.pointerIds[0]);
+    ASSERT_EQ(0, motionArgs.pointerProperties[0].id);
+    ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
             toDisplayX(x1), toDisplayY(y1), 1, 0, 0, 0, 0, 0, 0));
     ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON);
@@ -3233,10 +3258,13 @@
             motionArgs.action);
     ASSERT_EQ(0, motionArgs.flags);
     ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
+    ASSERT_EQ(0, motionArgs.buttonState);
     ASSERT_EQ(0, motionArgs.edgeFlags);
     ASSERT_EQ(size_t(2), motionArgs.pointerCount);
-    ASSERT_EQ(0, motionArgs.pointerIds[0]);
-    ASSERT_EQ(1, motionArgs.pointerIds[1]);
+    ASSERT_EQ(0, motionArgs.pointerProperties[0].id);
+    ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
+    ASSERT_EQ(1, motionArgs.pointerProperties[1].id);
+    ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[1].toolType);
     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
             toDisplayX(x1), toDisplayY(y1), 1, 0, 0, 0, 0, 0, 0));
     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[1],
@@ -3261,10 +3289,13 @@
     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
     ASSERT_EQ(0, motionArgs.flags);
     ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
+    ASSERT_EQ(0, motionArgs.buttonState);
     ASSERT_EQ(0, motionArgs.edgeFlags);
     ASSERT_EQ(size_t(2), motionArgs.pointerCount);
-    ASSERT_EQ(0, motionArgs.pointerIds[0]);
-    ASSERT_EQ(1, motionArgs.pointerIds[1]);
+    ASSERT_EQ(0, motionArgs.pointerProperties[0].id);
+    ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
+    ASSERT_EQ(1, motionArgs.pointerProperties[1].id);
+    ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[1].toolType);
     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
             toDisplayX(x1), toDisplayY(y1), 1, 0, 0, 0, 0, 0, 0));
     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[1],
@@ -3288,10 +3319,13 @@
             motionArgs.action);
     ASSERT_EQ(0, motionArgs.flags);
     ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
+    ASSERT_EQ(0, motionArgs.buttonState);
     ASSERT_EQ(0, motionArgs.edgeFlags);
     ASSERT_EQ(size_t(2), motionArgs.pointerCount);
-    ASSERT_EQ(0, motionArgs.pointerIds[0]);
-    ASSERT_EQ(1, motionArgs.pointerIds[1]);
+    ASSERT_EQ(0, motionArgs.pointerProperties[0].id);
+    ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
+    ASSERT_EQ(1, motionArgs.pointerProperties[1].id);
+    ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[1].toolType);
     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
             toDisplayX(x1), toDisplayY(y1), 1, 0, 0, 0, 0, 0, 0));
     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[1],
@@ -3308,9 +3342,11 @@
     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
     ASSERT_EQ(0, motionArgs.flags);
     ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
+    ASSERT_EQ(0, motionArgs.buttonState);
     ASSERT_EQ(0, motionArgs.edgeFlags);
     ASSERT_EQ(size_t(1), motionArgs.pointerCount);
-    ASSERT_EQ(1, motionArgs.pointerIds[0]);
+    ASSERT_EQ(1, motionArgs.pointerProperties[0].id);
+    ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
             toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0));
     ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON);
@@ -3331,9 +3367,11 @@
     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
     ASSERT_EQ(0, motionArgs.flags);
     ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
+    ASSERT_EQ(0, motionArgs.buttonState);
     ASSERT_EQ(0, motionArgs.edgeFlags);
     ASSERT_EQ(size_t(1), motionArgs.pointerCount);
-    ASSERT_EQ(1, motionArgs.pointerIds[0]);
+    ASSERT_EQ(1, motionArgs.pointerProperties[0].id);
+    ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
             toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0));
     ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON);
@@ -3357,10 +3395,13 @@
             motionArgs.action);
     ASSERT_EQ(0, motionArgs.flags);
     ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
+    ASSERT_EQ(0, motionArgs.buttonState);
     ASSERT_EQ(0, motionArgs.edgeFlags);
     ASSERT_EQ(size_t(2), motionArgs.pointerCount);
-    ASSERT_EQ(0, motionArgs.pointerIds[0]);
-    ASSERT_EQ(1, motionArgs.pointerIds[1]);
+    ASSERT_EQ(0, motionArgs.pointerProperties[0].id);
+    ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
+    ASSERT_EQ(1, motionArgs.pointerProperties[1].id);
+    ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[1].toolType);
     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
             toDisplayX(x3), toDisplayY(y3), 1, 0, 0, 0, 0, 0, 0));
     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[1],
@@ -3384,10 +3425,13 @@
             motionArgs.action);
     ASSERT_EQ(0, motionArgs.flags);
     ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
+    ASSERT_EQ(0, motionArgs.buttonState);
     ASSERT_EQ(0, motionArgs.edgeFlags);
     ASSERT_EQ(size_t(2), motionArgs.pointerCount);
-    ASSERT_EQ(0, motionArgs.pointerIds[0]);
-    ASSERT_EQ(1, motionArgs.pointerIds[1]);
+    ASSERT_EQ(0, motionArgs.pointerProperties[0].id);
+    ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
+    ASSERT_EQ(1, motionArgs.pointerProperties[1].id);
+    ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[1].toolType);
     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
             toDisplayX(x3), toDisplayY(y3), 1, 0, 0, 0, 0, 0, 0));
     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[1],
@@ -3404,9 +3448,11 @@
     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
     ASSERT_EQ(0, motionArgs.flags);
     ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
+    ASSERT_EQ(0, motionArgs.buttonState);
     ASSERT_EQ(0, motionArgs.edgeFlags);
     ASSERT_EQ(size_t(1), motionArgs.pointerCount);
-    ASSERT_EQ(0, motionArgs.pointerIds[0]);
+    ASSERT_EQ(0, motionArgs.pointerProperties[0].id);
+    ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
             toDisplayX(x3), toDisplayY(y3), 1, 0, 0, 0, 0, 0, 0));
     ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON);
@@ -3425,9 +3471,11 @@
     ASSERT_EQ(AMOTION_EVENT_ACTION_UP, motionArgs.action);
     ASSERT_EQ(0, motionArgs.flags);
     ASSERT_EQ(AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_ON, motionArgs.metaState);
+    ASSERT_EQ(0, motionArgs.buttonState);
     ASSERT_EQ(0, motionArgs.edgeFlags);
     ASSERT_EQ(size_t(1), motionArgs.pointerCount);
-    ASSERT_EQ(0, motionArgs.pointerIds[0]);
+    ASSERT_EQ(0, motionArgs.pointerProperties[0].id);
+    ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
             toDisplayX(x3), toDisplayY(y3), 1, 0, 0, 0, 0, 0, 0));
     ASSERT_NEAR(X_PRECISION, motionArgs.xPrecision, EPSILON);
@@ -3464,7 +3512,8 @@
     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
     ASSERT_EQ(AMOTION_EVENT_ACTION_DOWN, motionArgs.action);
     ASSERT_EQ(size_t(1), motionArgs.pointerCount);
-    ASSERT_EQ(1, motionArgs.pointerIds[0]);
+    ASSERT_EQ(1, motionArgs.pointerProperties[0].id);
+    ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
             toDisplayX(x1), toDisplayY(y1), 1, 0, 0, 0, 0, 0, 0));
 
@@ -3472,8 +3521,10 @@
     ASSERT_EQ(AMOTION_EVENT_ACTION_POINTER_DOWN | (1 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT),
             motionArgs.action);
     ASSERT_EQ(size_t(2), motionArgs.pointerCount);
-    ASSERT_EQ(1, motionArgs.pointerIds[0]);
-    ASSERT_EQ(2, motionArgs.pointerIds[1]);
+    ASSERT_EQ(1, motionArgs.pointerProperties[0].id);
+    ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
+    ASSERT_EQ(2, motionArgs.pointerProperties[1].id);
+    ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[1].toolType);
     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
             toDisplayX(x1), toDisplayY(y1), 1, 0, 0, 0, 0, 0, 0));
     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[1],
@@ -3492,8 +3543,10 @@
     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
     ASSERT_EQ(size_t(2), motionArgs.pointerCount);
-    ASSERT_EQ(1, motionArgs.pointerIds[0]);
-    ASSERT_EQ(2, motionArgs.pointerIds[1]);
+    ASSERT_EQ(1, motionArgs.pointerProperties[0].id);
+    ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
+    ASSERT_EQ(2, motionArgs.pointerProperties[1].id);
+    ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[1].toolType);
     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
             toDisplayX(x1), toDisplayY(y1), 1, 0, 0, 0, 0, 0, 0));
     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[1],
@@ -3510,8 +3563,10 @@
     ASSERT_EQ(AMOTION_EVENT_ACTION_POINTER_UP | (0 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT),
             motionArgs.action);
     ASSERT_EQ(size_t(2), motionArgs.pointerCount);
-    ASSERT_EQ(1, motionArgs.pointerIds[0]);
-    ASSERT_EQ(2, motionArgs.pointerIds[1]);
+    ASSERT_EQ(1, motionArgs.pointerProperties[0].id);
+    ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
+    ASSERT_EQ(2, motionArgs.pointerProperties[1].id);
+    ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[1].toolType);
     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
             toDisplayX(x1), toDisplayY(y1), 1, 0, 0, 0, 0, 0, 0));
     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[1],
@@ -3520,7 +3575,8 @@
     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
     ASSERT_EQ(size_t(1), motionArgs.pointerCount);
-    ASSERT_EQ(2, motionArgs.pointerIds[0]);
+    ASSERT_EQ(2, motionArgs.pointerProperties[0].id);
+    ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
             toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0));
 
@@ -3534,7 +3590,8 @@
     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
     ASSERT_EQ(size_t(1), motionArgs.pointerCount);
-    ASSERT_EQ(2, motionArgs.pointerIds[0]);
+    ASSERT_EQ(2, motionArgs.pointerProperties[0].id);
+    ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
             toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0));
 
@@ -3552,8 +3609,10 @@
     ASSERT_EQ(AMOTION_EVENT_ACTION_POINTER_DOWN | (1 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT),
             motionArgs.action);
     ASSERT_EQ(size_t(2), motionArgs.pointerCount);
-    ASSERT_EQ(2, motionArgs.pointerIds[0]);
-    ASSERT_EQ(3, motionArgs.pointerIds[1]);
+    ASSERT_EQ(2, motionArgs.pointerProperties[0].id);
+    ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
+    ASSERT_EQ(3, motionArgs.pointerProperties[1].id);
+    ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[1].toolType);
     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
             toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0));
     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[1],
@@ -3570,8 +3629,10 @@
     ASSERT_EQ(AMOTION_EVENT_ACTION_POINTER_UP | (0 << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT),
             motionArgs.action);
     ASSERT_EQ(size_t(2), motionArgs.pointerCount);
-    ASSERT_EQ(2, motionArgs.pointerIds[0]);
-    ASSERT_EQ(3, motionArgs.pointerIds[1]);
+    ASSERT_EQ(2, motionArgs.pointerProperties[0].id);
+    ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
+    ASSERT_EQ(3, motionArgs.pointerProperties[1].id);
+    ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[1].toolType);
     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
             toDisplayX(x2), toDisplayY(y2), 1, 0, 0, 0, 0, 0, 0));
     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[1],
@@ -3580,7 +3641,8 @@
     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
     ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, motionArgs.action);
     ASSERT_EQ(size_t(1), motionArgs.pointerCount);
-    ASSERT_EQ(3, motionArgs.pointerIds[0]);
+    ASSERT_EQ(3, motionArgs.pointerProperties[0].id);
+    ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
             toDisplayX(x3), toDisplayY(y3), 1, 0, 0, 0, 0, 0, 0));
 
@@ -3591,7 +3653,8 @@
     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&motionArgs));
     ASSERT_EQ(AMOTION_EVENT_ACTION_UP, motionArgs.action);
     ASSERT_EQ(size_t(1), motionArgs.pointerCount);
-    ASSERT_EQ(3, motionArgs.pointerIds[0]);
+    ASSERT_EQ(3, motionArgs.pointerProperties[0].id);
+    ASSERT_EQ(AMOTION_EVENT_TOOL_TYPE_FINGER, motionArgs.pointerProperties[0].toolType);
     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(motionArgs.pointerCoords[0],
             toDisplayX(x3), toDisplayY(y3), 1, 0, 0, 0, 0, 0, 0));
 
@@ -3641,7 +3704,7 @@
 
     FakeInputDispatcher::NotifyMotionArgs args;
     ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args));
-    ASSERT_EQ(id, args.pointerIds[0]);
+    ASSERT_EQ(id, args.pointerProperties[0].id);
     ASSERT_NO_FATAL_FAILURE(assertPointerCoords(args.pointerCoords[0],
             x, y, pressure, size, touchMajor, touchMinor, toolMajor, toolMinor, orientation));
 }
diff --git a/services/java/com/android/server/accessibility/TouchExplorer.java b/services/java/com/android/server/accessibility/TouchExplorer.java
index 4ba6060..fb97089 100644
--- a/services/java/com/android/server/accessibility/TouchExplorer.java
+++ b/services/java/com/android/server/accessibility/TouchExplorer.java
@@ -31,6 +31,7 @@
 import android.view.ViewConfiguration;
 import android.view.WindowManagerPolicy;
 import android.view.MotionEvent.PointerCoords;
+import android.view.MotionEvent.PointerProperties;
 import android.view.accessibility.AccessibilityEvent;
 import android.view.accessibility.AccessibilityManager;
 
@@ -112,8 +113,13 @@
     // Temporary array for mapping new to old pointer IDs while filtering inactive pointers.
     private final int [] mTempNewToOldPointerIndexMap = new int[MAX_POINTER_COUNT];
 
+    // Temporary array for storing PointerProperties
+    private final PointerProperties[] mTempPointerProperties =
+            PointerProperties.createArray(MAX_POINTER_COUNT);
+
     // Temporary array for storing PointerCoords
-    private final PointerCoords[] mTempPointerCoords= new PointerCoords[MAX_POINTER_COUNT];
+    private final PointerCoords[] mTempPointerCoords =
+            PointerCoords.createArray(MAX_POINTER_COUNT);
 
     // The maximal distance between two pointers so they are
     // considered to be performing a drag operation.
@@ -172,11 +178,6 @@
         mHandler = new Handler(context.getMainLooper());
         mSendHoverDelayed = new SendHoverDelayed();
         mAccessibilityManager = AccessibilityManager.getInstance(context);
-
-        // Populate the temporary array with PointerCorrds to be reused.
-        for (int i = 0, count = mTempPointerCoords.length; i < count; i++) {
-            mTempPointerCoords[i] = new PointerCoords();
-        }
     }
 
     public void clear(MotionEvent event, int policyFlags) {
@@ -574,9 +575,9 @@
      * @param policyFlags The policy flags associated with the event.
      */
     private void sendDownForAllActiveNotInjectedPointers(MotionEvent prototype, int policyFlags) {
-        PointerCoords[] pointerCoords = mTempPointerCoords;
-        PointerTracker pointerTracker = mPointerTracker;
-        int[] pointerIds = mTempPointerIds;
+        final PointerProperties[] pointerProperties = mTempPointerProperties;
+        final PointerCoords[] pointerCoords = mTempPointerCoords;
+        final PointerTracker pointerTracker = mPointerTracker;
         int pointerDataIndex = 0;
 
         final int pinterCount = prototype.getPointerCount();
@@ -593,7 +594,7 @@
             }
 
             // Populate and inject an event for the current pointer.
-            pointerIds[pointerDataIndex] = pointerId;
+            prototype.getPointerProperties(i, pointerProperties[pointerDataIndex]);
             prototype.getPointerCoords(i, pointerCoords[pointerDataIndex]);
 
             final long downTime = pointerTracker.getLastInjectedDownEventTime();
@@ -602,7 +603,8 @@
             final long pointerDownTime = SystemClock.uptimeMillis();
 
             MotionEvent event = MotionEvent.obtain(downTime, pointerDownTime,
-                    action, pointerCount, pointerIds, pointerCoords, prototype.getMetaState(),
+                    action, pointerCount, pointerProperties, pointerCoords,
+                    prototype.getMetaState(), prototype.getButtonState(),
                     prototype.getXPrecision(), prototype.getYPrecision(), prototype.getDeviceId(),
                     prototype.getEdgeFlags(), prototype.getSource(), prototype.getFlags());
             sendMotionEvent(event, policyFlags);
@@ -620,9 +622,9 @@
      * @param policyFlags The policy flags associated with the event.
      */
     private void sendUpForInjectedDownPointers(MotionEvent prototype, int policyFlags) {
-        PointerTracker pointerTracker = mPointerTracker;
-        PointerCoords[] pointerCoords = mTempPointerCoords;
-        int[] pointerIds = mTempPointerIds;
+        final PointerTracker pointerTracker = mPointerTracker;
+        final PointerProperties[] pointerProperties = mTempPointerProperties;
+        final PointerCoords[] pointerCoords = mTempPointerCoords;
         int pointerDataIndex = 0;
 
         final int pointerCount = prototype.getPointerCount(); 
@@ -635,7 +637,7 @@
             }
 
             // Populate and inject event.
-            pointerIds[pointerDataIndex] = pointerId;
+            prototype.getPointerProperties(i, pointerProperties[pointerDataIndex]);
             prototype.getPointerCoords(i, pointerCoords[pointerDataIndex]);
 
             final long downTime = pointerTracker.getLastInjectedDownEventTime();
@@ -644,7 +646,8 @@
             final long eventTime = SystemClock.uptimeMillis();
 
             MotionEvent event = MotionEvent.obtain(downTime, eventTime, action,
-                    newPointerCount, pointerIds, pointerCoords, prototype.getMetaState(),
+                    newPointerCount, pointerProperties, pointerCoords,
+                    prototype.getMetaState(), prototype.getButtonState(),
                     prototype.getXPrecision(), prototype.getYPrecision(), prototype.getDeviceId(),
                     prototype.getEdgeFlags(), prototype.getSource(), prototype.getFlags());
 
@@ -678,8 +681,8 @@
         }
 
         // Filter out inactive pointers from the event and inject it.
-        PointerCoords[] pointerCoords = mTempPointerCoords;
-        int[] pointerIds = mTempPointerIds;
+        final PointerProperties[] pointerProperties = mTempPointerProperties;
+        final PointerCoords[] pointerCoords = mTempPointerCoords;
         int [] newToOldPointerIndexMap = mTempNewToOldPointerIndexMap;
         int newPointerIndex = 0;
         int actionIndex = prototype.getActionIndex();
@@ -698,7 +701,7 @@
             }
 
             newToOldPointerIndexMap[newPointerIndex] = oldPointerIndex;
-            pointerIds[newPointerIndex] = pointerId;
+            prototype.getPointerProperties(oldPointerIndex, pointerProperties[newPointerIndex]);
             prototype.getPointerCoords(oldPointerIndex, pointerCoords[newPointerIndex]);
 
             newPointerIndex++;
@@ -714,7 +717,8 @@
         final int action = computeInjectionAction(prototype.getActionMasked(), actionIndex);
         final int newPointerCount = newPointerIndex;
         MotionEvent prunedEvent = MotionEvent.obtain(downTime, prototype.getEventTime(), action,
-                newPointerCount, pointerIds, pointerCoords, prototype.getMetaState(),
+                newPointerCount, pointerProperties, pointerCoords,
+                prototype.getMetaState(), prototype.getButtonState(),
                 prototype.getXPrecision(), prototype.getYPrecision(), prototype.getDeviceId(),
                 prototype.getEdgeFlags(), prototype.getSource(),prototype.getFlags());
 
@@ -743,18 +747,19 @@
      * @param policyFlags The policy flags associated with the event.
      */
     private void sendDragEvent(MotionEvent prototype, int action, int policyFlags) {
-        PointerCoords[] pointerCoords = mTempPointerCoords;
-        int[] pointerIds = mTempPointerIds;
+        final PointerProperties[] pointerProperties = mTempPointerProperties;
+        final PointerCoords[] pointerCoords = mTempPointerCoords;
         final int pointerId = mDraggingPointerId;
         final int pointerIndex = prototype.findPointerIndex(pointerId);
 
         // Populate the event with the date of the dragging pointer and inject it.
-        pointerIds[0] = pointerId;
+        prototype.getPointerProperties(pointerIndex, pointerProperties[0]);
         prototype.getPointerCoords(pointerIndex, pointerCoords[0]);
 
         MotionEvent event = MotionEvent.obtain(prototype.getDownTime(),
-                prototype.getEventTime(), action, 1, pointerIds, pointerCoords,
-                prototype.getMetaState(), prototype.getXPrecision(), prototype.getYPrecision(),
+                prototype.getEventTime(), action, 1, pointerProperties, pointerCoords,
+                prototype.getMetaState(), prototype.getButtonState(),
+                prototype.getXPrecision(), prototype.getYPrecision(),
                 prototype.getDeviceId(), prototype.getEdgeFlags(), prototype.getSource(),
                 prototype.getFlags());
 
@@ -769,32 +774,27 @@
      * @param policyFlags The policy flags associated with the event.
      */
     private void sendActionDownAndUp(MotionEvent prototype, int policyFlags) {
-        PointerCoords[] pointerCoords = mTempPointerCoords;
-        int[] pointerIds = mTempPointerIds;
+        final PointerProperties[] pointerProperties = mTempPointerProperties;
+        final PointerCoords[] pointerCoords = mTempPointerCoords;
         final int pointerId = mPointerTracker.getLastReceivedUpPointerId();
         final int pointerIndex = prototype.findPointerIndex(pointerId);
 
         // Send down.
-        pointerIds[0] = pointerId;
+        prototype.getPointerProperties(pointerIndex, pointerProperties[0]);
         prototype.getPointerCoords(pointerIndex, pointerCoords[0]);
 
         final long downTime = SystemClock.uptimeMillis();
-
-        MotionEvent downEvent = MotionEvent.obtain(downTime, downTime, MotionEvent.ACTION_DOWN,
-                1, mTempPointerIds, mTempPointerCoords, prototype.getMetaState(),
+        MotionEvent event = MotionEvent.obtain(downTime, downTime, MotionEvent.ACTION_DOWN,
+                1, pointerProperties, pointerCoords,
+                prototype.getMetaState(), prototype.getButtonState(),
                 prototype.getXPrecision(), prototype.getYPrecision(), prototype.getDeviceId(),
                 prototype.getEdgeFlags(), prototype.getSource(), prototype.getFlags());
-
-        // Clone the down event before recycling it.
-        MotionEvent upEvent = MotionEvent.obtain(downEvent);
-
-        sendMotionEvent(downEvent, policyFlags);
-        downEvent.recycle();
+        sendMotionEvent(event, policyFlags);
 
         // Send up.
-        upEvent.setAction(MotionEvent.ACTION_UP);
-        sendMotionEvent(upEvent, policyFlags);
-        upEvent.recycle();
+        event.setAction(MotionEvent.ACTION_UP);
+        sendMotionEvent(event, policyFlags);
+        event.recycle();
     }
 
     /**
@@ -807,21 +807,20 @@
      */
     private void sendHoverEvent(MotionEvent prototype, int action, int pointerIndex, int
             policyFlags) {
-        PointerCoords[] pointerCoords = mTempPointerCoords;
-        int[] pointerIds = mTempPointerIds;
+        final PointerProperties[] pointerProperties = mTempPointerProperties;
+        final PointerCoords[] pointerCoords = mTempPointerCoords;
 
-        // Keep only data relevant to a hover event.
-        pointerIds[0] = prototype.getPointerId(pointerIndex);
-        pointerCoords[0].clear();
-        pointerCoords[0].x = prototype.getX(pointerIndex);
-        pointerCoords[0].y = prototype.getY(pointerIndex);
+        prototype.getPointerProperties(pointerIndex, pointerProperties[0]);
+        prototype.getPointerCoords(pointerIndex, pointerCoords[0]);
 
         final long downTime = mPointerTracker.getLastInjectedDownEventTime();
 
         // Populate and inject a hover event.
         MotionEvent hoverEvent = MotionEvent.obtain(downTime, prototype.getEventTime(), action,
-                1, pointerIds, pointerCoords, 0, 0, 0, prototype.getDeviceId(), 0,
-                prototype.getSource(), 0);
+                1, pointerProperties, pointerCoords,
+                prototype.getMetaState(), prototype.getButtonState(),
+                prototype.getXPrecision(), prototype.getYPrecision(), prototype.getDeviceId(),
+                prototype.getEdgeFlags(), prototype.getSource(), prototype.getFlags());
 
         sendMotionEvent(hoverEvent, policyFlags);
         hoverEvent.recycle();