Why is MotionEvent.ACTION_POINTER_UP not recorded consistently?

Question

I thought pinch would always trigger MotionEvent.ACTION_POINTER_UP, but it happens only about 50% of the time (it varies a lot) for an app on at least two tested tablet devices. It appears to be random. I do not know how to pinch to make it happen consistently.

The code is very straightforward as the following overridden method of the activity in question:

@Override
public boolean onTouchEvent(MotionEvent event) {
    switch (event.getAction())
    {
    ...
    case MotionEvent.ACTION_POINTER_UP:

        Log.d("Debug", "ACTION_POINTER_UP triggered");
    default:
        break;
    }
    ...
}

Could anyone shed some light on this?

Answer 1

You may change your code to use getActionMasked().

@Override
public boolean onTouchEvent(MotionEvent event) {
    switch (event.getActionMasked())
    {
    //...
    case MotionEvent.ACTION_POINTER_UP:

        Log.d("Debug", "ACTION_POINTER_UP triggered");
    default:
        break;
    }
    //...
}

---

MotionEven getAction() reports an integer which consists of both ACTION_whatever and the pointer index left-shifted by ACTION_POINTER_INDEX_SHIFT (8) bits.

Return the kind of action being performed. Consider using getActionMasked() and getActionIndex() to retrieve the separate masked action and pointer index.

Returns The action, such as ACTION_DOWN or the combination of ACTION_POINTER_DOWN with a shifted pointer index.

getAction() can be quite confusing to work with in multi-touch situations. If you want to get the kind of action (ACTION_DOWN, ACTION_POINTER_DOWN, and so on), which your case most likely is, you may use getActionMasked() instead of getAction().

• getActionMasked() always returns ACTION_whatever, without the pointer index bits.

• getAction() returns (getActionIndex() << 8 | ACTION_whatever). (pointer indexes are very counter-intuitive, with Android trying to re-use the lowest indices available giving strange behavior if you use them directly, but that's another story, here better use getActionMasked() and not worry about indices). This is numerically equal to getActionMasked() only when the pointer has index=0, therefore you will see the "random" behavior: As you complete each pinch "naturally",

  • sometimes you may have released pointer 0 first, then pointer 1 last, you get 2 events that getAction() returns ACTION_POINTER_UP followed by 1<<8 | ACTION_UP respectively, and hits the case ACTION_POINTER_UP label on the first event.
  • The other time you may have released pointer 1 first, then pointer 0 last, you get 2 events that getAction() return 1<<8 | ACTION_POINTER_UP followed by ACTION_UP. There is no case label for these, all get down to the default.

• If you use getActionMasked(), you get ACTION_POINTER_UP followed by ACTION_UP, in both cases consistently.