Example usage for android.support.v4.view MotionEventCompat ACTION_POINTER

Introduction

In this page you can find the example usage for android.support.v4.view MotionEventCompat ACTION_POINTER_UP.

Prototype

int ACTION_POINTER_UP

To view the source code for android.support.v4.view MotionEventCompat ACTION_POINTER_UP.

Click Source Link

Document

Synonym for MotionEvent#ACTION_POINTER_UP .

Usage

From source file:com.tellh.swipetorefreshlayoutgoogle.SwipeRefreshTestLayout.java

@Override
public boolean onTouchEvent(MotionEvent ev) {
    final int action = MotionEventCompat.getActionMasked(ev);
    int pointerIndex = -1;

    if (mReturningToStart && action == MotionEvent.ACTION_DOWN) {
        mReturningToStart = false;//from w w w  .  j  a v  a2  s  . c  om
    }

    //??CircleView????mNestedScrollInProgress??
    if (!isEnabled() || mReturningToStart || canChildScrollUp() || mNestedScrollInProgress) {
        // Fail fast if we're not in a state where a swipe is possible
        return false;
    }

    switch (action) {
    case MotionEvent.ACTION_DOWN:
        mActivePointerId = MotionEventCompat.getPointerId(ev, 0);
        mIsBeingDragged = false;
        break;

    case MotionEvent.ACTION_MOVE: {
        pointerIndex = MotionEventCompat.findPointerIndex(ev, mActivePointerId);
        if (pointerIndex < 0) {
            Log.e(LOG_TAG, "Got ACTION_MOVE event but have an invalid active pointer id.");
            return false;
        }

        final float y = MotionEventCompat.getY(ev, pointerIndex);
        //
        final float overscrollTop = (y - mInitialMotionY) * DRAG_RATE;
        if (mIsBeingDragged) {
            if (overscrollTop > 0) {
                //spinner??spinner
                //
                moveSpinner(overscrollTop);
            } else {
                return false;
            }
        }
        break;
    }
    //?
    case MotionEventCompat.ACTION_POINTER_DOWN: {
        pointerIndex = MotionEventCompat.getActionIndex(ev);
        if (pointerIndex < 0) {
            Log.e(LOG_TAG, "Got ACTION_POINTER_DOWN event but have an invalid action index.");
            return false;
        }
        mActivePointerId = MotionEventCompat.getPointerId(ev, pointerIndex);
        break;
    }

    case MotionEventCompat.ACTION_POINTER_UP:
        onSecondaryPointerUp(ev);
        break;

    //??
    case MotionEvent.ACTION_UP: {
        pointerIndex = MotionEventCompat.findPointerIndex(ev, mActivePointerId);
        if (pointerIndex < 0) {
            Log.e(LOG_TAG, "Got ACTION_UP event but don't have an active pointer id.");
            return false;
        }

        final float y = MotionEventCompat.getY(ev, pointerIndex);
        //??
        final float overscrollTop = (y - mInitialMotionY) * DRAG_RATE;
        mIsBeingDragged = false;
        //
        finishSpinner(overscrollTop);
        mActivePointerId = INVALID_POINTER;
        return false;
    }
    case MotionEvent.ACTION_CANCEL:
        return false;
    }

    return true;
}

From source file:com.example.gitnb.widget.SwipeRefreshLayout.java

@Override
public boolean onTouchEvent(MotionEvent ev) {
    final int action = MotionEventCompat.getActionMasked(ev);
    int pointerIndex = -1;

    if (mReturningToStart && action == MotionEvent.ACTION_DOWN) {
        mReturningToStart = false;/*  ww w . java 2 s.  c o m*/
    }

    if (!isEnabled() || mReturningToStart || canChildScrollUp() || mNestedScrollInProgress) {
        // Fail fast if we're not in a state where a swipe is possible
        return false;
    }

    switch (action) {
    case MotionEvent.ACTION_DOWN:
        mActivePointerId = MotionEventCompat.getPointerId(ev, 0);
        //mIsBeingDragged = false;
        break;

    case MotionEvent.ACTION_MOVE: {
        pointerIndex = MotionEventCompat.findPointerIndex(ev, mActivePointerId);
        if (pointerIndex < 0) {
            Log.e(LOG_TAG, "Got ACTION_MOVE event but have an invalid active pointer id.");
            return false;
        }

        final float y = MotionEventCompat.getY(ev, pointerIndex);
        final float overscrollTop = (y - mInitialMotionY) * DRAG_RATE;
        if (mIsBeingDragged) {
            if (overscrollTop > 0) {
                moveSpinner(overscrollTop);
            } else {
                return false;
            }
        }
        break;
    }
    case MotionEventCompat.ACTION_POINTER_DOWN: {
        pointerIndex = MotionEventCompat.getActionIndex(ev);
        if (pointerIndex < 0) {
            Log.e(LOG_TAG, "Got ACTION_POINTER_DOWN event but have an invalid action index.");
            return false;
        }
        mActivePointerId = MotionEventCompat.getPointerId(ev, pointerIndex);
        break;
    }

    case MotionEventCompat.ACTION_POINTER_UP:
        onSecondaryPointerUp(ev);
        break;

    case MotionEvent.ACTION_UP: {
        pointerIndex = MotionEventCompat.findPointerIndex(ev, mActivePointerId);
        if (pointerIndex < 0) {
            Log.e(LOG_TAG, "Got ACTION_UP event but don't have an active pointer id.");
            return false;
        }

        final float y = MotionEventCompat.getY(ev, pointerIndex);
        final float overscrollTop = (y - mInitialMotionY) * DRAG_RATE;
        mIsBeingDragged = false;
        finishSpinner(overscrollTop);
        mActivePointerId = INVALID_POINTER;
        return false;
    }
    case MotionEvent.ACTION_CANCEL:
        return false;
    }

    return true;
}

From source file:cn.edu.bit.bookstore.bookstore_android.widget.PullToRefreshLayout.java

@Override
public boolean onTouchEvent(MotionEvent ev) {
    final int action = MotionEventCompat.getActionMasked(ev);
    int pointerIndex = -1;

    if (mReturningToStart && action == MotionEvent.ACTION_DOWN) {
        mReturningToStart = false;/*from  w  w w .ja  v a 2s .  co m*/
    }

    if (!isEnabled() || mReturningToStart || canChildScrollUp() || mNestedScrollInProgress) {
        // Fail fast if we're not in a state where a swipe is possible
        return false;
    }

    switch (action) {
    case MotionEvent.ACTION_DOWN:
        mActivePointerId = MotionEventCompat.getPointerId(ev, 0);
        mIsBeingDragged = false;
        break;

    case MotionEvent.ACTION_MOVE: {
        pointerIndex = MotionEventCompat.findPointerIndex(ev, mActivePointerId);
        if (pointerIndex < 0) {
            Log.e(LOG_TAG, "Got ACTION_MOVE event but have an invalid active pointer id.");
            return false;
        }

        final float y = MotionEventCompat.getY(ev, pointerIndex);
        final float overscrollTop = (y - mInitialMotionY) * DRAG_RATE;
        if (mIsBeingDragged) {
            if (overscrollTop > 0) {
                moveSpinner(overscrollTop);
            } else {
                return false;
            }
        }
        break;
    }
    case MotionEventCompat.ACTION_POINTER_DOWN: {
        pointerIndex = MotionEventCompat.getActionIndex(ev);
        if (pointerIndex < 0) {
            Log.e(LOG_TAG, "Got ACTION_POINTER_DOWN event but have an invalid action index.");
            return false;
        }
        mActivePointerId = MotionEventCompat.getPointerId(ev, pointerIndex);
        break;
    }

    case MotionEventCompat.ACTION_POINTER_UP:
        onSecondaryPointerUp(ev);
        break;

    case MotionEvent.ACTION_UP: {
        pointerIndex = MotionEventCompat.findPointerIndex(ev, mActivePointerId);
        if (pointerIndex < 0) {
            Log.e(LOG_TAG, "Got ACTION_UP event but don't have an active pointer id.");
            return false;
        }

        final float y = MotionEventCompat.getY(ev, pointerIndex);
        final float overscrollTop = (y - mInitialMotionY) * DRAG_RATE;
        mIsBeingDragged = false;
        finishSpinner(overscrollTop);
        mActivePointerId = INVALID_POINTER;
        return false;
    }
    case MotionEvent.ACTION_CANCEL:
        return false;
    }

    return true;
}

From source file:com.fishstix.dosboxfree.DBGLSurfaceView.java

@Override
public boolean onTouchEvent(final MotionEvent event) {
    final int pointerIndex = MotionEventCompat.getActionIndex(event);
    final int pointCnt = mWrap.getPointerCount(event);
    final int pointerId = MotionEventCompat.getPointerId(event, pointerIndex);
    if (pointCnt < MAX_POINT_CNT) {
        //if (pointerIndex <= MAX_POINT_CNT - 1){
        {/*w w w . jav  a2  s  .c  o m*/
            for (int i = 0; i < pointCnt; i++) {
                int id = MotionEventCompat.getPointerId(event, i);
                if (id < MAX_POINT_CNT) {
                    x_last[id] = x[id];
                    y_last[id] = y[id];
                    x[id] = mWrap.getX(event, i);
                    y[id] = mWrap.getY(event, i);
                }
            }
            switch (MotionEventCompat.getActionMasked(event)) {
            case MotionEvent.ACTION_DOWN:
            case MotionEventCompat.ACTION_POINTER_DOWN:
                int button = -1;
                // Save the ID of this pointer
                if (mInputMode == INPUT_MODE_MOUSE) {
                } else if (mInputMode == INPUT_MODE_REAL_JOYSTICK) {
                    int buttonState = mWrap.getButtonState(event);
                    if ((buttonState & TouchEventWrapper.BUTTON_PRIMARY) != 0) {
                        button = BTN_A;
                    } else if ((buttonState & TouchEventWrapper.BUTTON_SECONDARY) != 0) {
                        button = BTN_B;
                    }
                    DosBoxControl.nativeJoystick(0, 0, ACTION_DOWN, button);
                } else if (mInputMode == INPUT_MODE_REAL_MOUSE) {
                    int buttonState = mWrap.getButtonState(event);
                    if ((buttonState & TouchEventWrapper.BUTTON_PRIMARY) != 0) {
                        button = BTN_A;
                    } else if ((buttonState & TouchEventWrapper.BUTTON_SECONDARY) != 0) {
                        button = BTN_B;
                    } else if (buttonState == 0) {
                        // handle trackpad presses as button clicks
                        button = BTN_A;
                    }
                    DosBoxControl.nativeMouse(0, 0, 0, 0, ACTION_DOWN, button);
                }
                mButtonDown[pointerId] = button;
                break;
            case MotionEvent.ACTION_UP:
            case MotionEventCompat.ACTION_POINTER_UP:
                if (mInputMode == INPUT_MODE_MOUSE) {
                    if (mLongClick) {
                        // single tap long click release
                        DosBoxControl.nativeMouse(0, 0, 0, 0, ACTION_UP,
                                mGestureSingleClick - GESTURE_LEFT_CLICK);
                        mLongClick = false;
                        Log.i("DosBoxTurbo", "SingleTap Long Click Release");
                        return true;
                    } else if (mDoubleLong) {
                        // double tap long click release
                        try {
                            Thread.sleep(CLICK_DELAY);
                        } catch (InterruptedException e) {
                        }
                        DosBoxControl.nativeMouse(0, 0, -1, -1, ACTION_UP,
                                mGestureDoubleClick - GESTURE_LEFT_CLICK);
                        Log.i("DosBoxTurbo", "DoubleTap Long Click Release");
                        mDoubleLong = false;
                        //return true;
                    } else if (pointCnt == 2) {
                        // handle 2 finger tap gesture
                        if (mLongPress) {
                            if (!mTwoFingerAction) {
                                // press button down
                                Log.i("DosBoxTurbo", "2-Finger Long Click Down");
                                DosBoxControl.nativeMouse(0, 0, -1, -1, ACTION_DOWN,
                                        mGestureTwoFinger - GESTURE_LEFT_CLICK);
                                mTwoFingerAction = true;
                            } else {
                                // already pressing button - release and press again
                                Log.i("DosBoxTurbo", "2-Finger Long Click - AGAIN");
                                DosBoxControl.nativeMouse(0, 0, -1, -1, ACTION_UP,
                                        mGestureTwoFinger - GESTURE_LEFT_CLICK);
                                try {
                                    Thread.sleep(CLICK_DELAY);
                                } catch (InterruptedException e) {
                                }
                                DosBoxControl.nativeMouse(0, 0, -1, -1, ACTION_DOWN,
                                        mGestureTwoFinger - GESTURE_LEFT_CLICK);
                            }
                        } else {
                            Log.i("DosBoxTurbo", "2-Finger Long Click Down-UP");
                            mouseClick(mGestureTwoFinger - GESTURE_LEFT_CLICK);
                        }
                        return true;
                    } else if ((pointCnt == 1) && mTwoFingerAction) {
                        // release two finger gesture
                        Log.i("DosBoxTurbo", "2-Finger Long Click Release");
                        DosBoxControl.nativeMouse(0, 0, -1, -1, ACTION_UP,
                                mGestureTwoFinger - GESTURE_LEFT_CLICK);
                        mTwoFingerAction = false;
                        //return true;
                    }
                } else if (mInputMode == INPUT_MODE_REAL_MOUSE) {
                    //Log.v("Mouse","BUTTON UP: " + (mButtonDown[pointerId]));
                    DosBoxControl.nativeMouse(0, 0, 0, 0, ACTION_UP, mButtonDown[pointerId]);
                    if (mWrap.getButtonState(event) > 0) {
                        return true; // capture button touches, pass screen touches through to gesture detetor
                    }
                } else if (mInputMode == INPUT_MODE_REAL_JOYSTICK) {
                    DosBoxControl.nativeJoystick(0, 0, ACTION_UP, (mButtonDown[pointerId]));
                    if (mWrap.getButtonState(event) > 0) {
                        return true;
                    }
                }
                break;
            case MotionEvent.ACTION_MOVE:
                //isTouch[pointerId] = true;
                switch (mInputMode) {
                case INPUT_MODE_SCROLL:
                    mScroll_x += (int) (x[pointerId] - x_last[pointerId]);
                    mScroll_y += (int) (y[pointerId] - y_last[pointerId]);
                    forceRedraw();
                    break;
                case INPUT_MODE_MOUSE:
                case INPUT_MODE_REAL_MOUSE:
                    if (event.getEventTime() + EVENT_THRESHOLD_DECAY < SystemClock.uptimeMillis()) {
                        Log.i("DosBoxTurbo", "eventtime: " + event.getEventTime() + " systemtime: "
                                + SystemClock.uptimeMillis());
                        return true; // get rid of old events
                    }
                    int idx = (!virtButton[0]) ? 0 : 1;
                    if (mAbsolute) {
                        DosBoxControl.nativeMouseWarp(x[idx], y[idx], mRenderer.x, mRenderer.y, mRenderer.width,
                                mRenderer.height);
                    } else {
                        DosBoxControl.nativeMouse((int) (x[idx] * mMouseSensitivityX),
                                (int) (y[idx] * mMouseSensitivityY), (int) (x_last[idx] * mMouseSensitivityX),
                                (int) (y_last[idx] * mMouseSensitivityY), ACTION_MOVE, -1);
                    }
                    if (mDebug) {
                        Log.d("DosBoxTurbo",
                                "mAbsolute=" + mAbsolute + " MotionEvent MOVE(" + pointerId + ")" + " x[idx]="
                                        + x[idx] + " y[idx]" + y[idx] + " mRenderer.x=" + mRenderer.x
                                        + " mRenderer.y=" + mRenderer.y + " mRenderer.width=" + mRenderer.width
                                        + " mRenderer.height=" + mRenderer.height);
                    }
                    try {
                        if (!mInputLowLatency)
                            Thread.sleep(95);
                        else
                            Thread.sleep(65);
                    } catch (InterruptedException e) {
                    }

                    break;
                default:
                }
                break;
            }
        }
    }
    try {
        Thread.sleep(15);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    //Thread.yield();
    return gestureScanner.onTouchEvent(event);
}

From source file:com.hippo.refreshlayout.RefreshLayout.java

private boolean headerInterceptTouchEvent(MotionEvent ev) {
    int pointerIndex;
    final int action = MotionEventCompat.getActionMasked(ev);
    switch (action) {
    case MotionEvent.ACTION_DOWN:
        setHeaderTargetOffsetTopAndBottom(mHeaderOriginalOffsetTop - mCircleView.getTop(), true);
        mActivePointerId = ev.getPointerId(0);
        mIsHeaderBeingDragged = false;//  w ww  . java 2 s.c  om

        pointerIndex = ev.findPointerIndex(mActivePointerId);
        if (pointerIndex < 0) {
            return false;
        }
        mInitialDownY = ev.getY(pointerIndex);
        break;

    case MotionEvent.ACTION_MOVE:
        if (mActivePointerId == INVALID_POINTER) {
            Log.e(LOG_TAG, "Got ACTION_MOVE event but don't have an active pointer id.");
            return false;
        }

        pointerIndex = ev.findPointerIndex(mActivePointerId);
        if (pointerIndex < 0) {
            return false;
        }
        final float y = ev.getY(pointerIndex);
        startHeaderDragging(y);
        break;

    case MotionEventCompat.ACTION_POINTER_UP:
        onSecondaryPointerUp(ev);
        break;

    case MotionEvent.ACTION_UP:
    case MotionEvent.ACTION_CANCEL:
        mIsHeaderBeingDragged = false;
        mActivePointerId = INVALID_POINTER;
        break;
    }

    return mIsHeaderBeingDragged;
}

From source file:com.usabusi.swiperefreshlayoutupdown.view.SwipeRefreshLayoutUpDown.java

@Override
public boolean onInterceptTouchEvent(MotionEvent ev) {
    ensureTarget();//from  www. ja  va  2s  .  co  m

    final int action = MotionEventCompat.getActionMasked(ev);

    if (mReturningToStart && action == MotionEvent.ACTION_DOWN) {
        mReturningToStart = false;
        Log.e(LOG_TAG, "mReturningToStart = false in onInterceptTouchEvent");
    }

    if (!isEnabled() || mReturningToStart || mRefreshing || mLoading) {
        boolean bisEnabled;
        bisEnabled = !isEnabled();
        String strLogout = String.format(
                "Got return false event in onInterceptTouchEvent.!isEnabled()= %b,mReturningToStart= %b,mRefreshing =%b,mRefreshing=%b",
                bisEnabled, mReturningToStart, mRefreshing, mLoading);
        Log.e(LOG_TAG, strLogout);
        // Fail fast if we're not in a state where a swipe is possible
        return false;
    }
    if ((mMode.permitsPullFromStartOnly() && canChildScrollUp())
            || (mMode.permitsPullFromEndOnly() && canChildScrollDown())) {
        boolean bcanChildScrollDown, bcanChildScrollUp;
        bcanChildScrollDown = canChildScrollDown();
        bcanChildScrollUp = canChildScrollUp();
        boolean bpermitsPullFromStartOnly = mMode.permitsPullFromStartOnly();
        String strLogout2 = String.format(
                "Got return false permitsPullFromStart/End Only event in onInterceptTouchEvent.canChildScrollDown()= %b,canChildScrollUp() =%b,bpermitsPullFromStartOnly=%b",
                bcanChildScrollDown, bcanChildScrollUp, bpermitsPullFromStartOnly);
        Log.e(LOG_TAG, strLogout2);
        // Fail fast if we're not in a state where a swipe is possible
        return false;
    }
    if (mMode.permitsPullFromBoth() && (canChildScrollUp() && canChildScrollDown())) {
        boolean bcanChildScrollDown, bcanChildScrollUp;
        bcanChildScrollDown = canChildScrollDown();
        bcanChildScrollUp = canChildScrollUp();
        String strLogout3 = String.format(
                "Got return false permitsPullFromBoth event in onInterceptTouchEvent.canChildScrollDown()= %b,canChildScrollUp() =%b",
                bcanChildScrollDown, bcanChildScrollUp);
        Log.e(LOG_TAG, strLogout3);
        // Fail fast if we're not in a state where a swipe is possible
        return false;
    }
    switch (action) {
    case MotionEvent.ACTION_DOWN:
        //v21 updown
        mLastMotionY = mInitialMotionY = ev.getY();
        setTargetOffsetTopAndBottom(mOriginalOffsetTop - mCircleView.getTop(), true);
        mActivePointerId = MotionEventCompat.getPointerId(ev, 0);
        mIsBeingDragged = false;
        final float initialMotionY = getMotionEventY(ev, mActivePointerId);
        if (initialMotionY == -1) {
            return false;
        }
        Log.e(LOG_TAG, "Got ACTION_DOWN event in onInterceptTouchEvent.");
        mInitialMotionY = initialMotionY;

        //v21 updown csdn version
        mStartPoint = mInitialMotionY;

        //up/down?????????
        //????canChildScrollUp/canChildScrollDown
        //????????????
        up = canChildScrollUp();
        down = canChildScrollDown();

        break;
    case MotionEvent.ACTION_MOVE:
        if (mActivePointerId == INVALID_POINTER) {
            Log.e(LOG_TAG,
                    "Got ACTION_MOVE event but don't have an active pointer id in onInterceptTouchEvent.");
            return false;
        } else
            Log.e(LOG_TAG, "Got ACTION_MOVE event in onInterceptTouchEvent.");
        /*
        //v20 updown
        final int pointerIndex = MotionEventCompat.findPointerIndex(ev, mActivePointerId);
        if (pointerIndex < 0) {
            Log.e(LOG_TAG, "Got ACTION_MOVE event but have an invalid active pointer id in onInterceptTouchEvent.");
            return false;
        }
        */
        final float y = getMotionEventY(ev, mActivePointerId);

        if (y == -1) {
            return false;
        }
        //v21 updown
        //float yDiff = y - mStartPoint;
        float yDiff = y - mInitialMotionY;

        //?????
        if ((mLastDirection == PullMode.PULL_FROM_START && yDiff < 0)
                || (mLastDirection == PullMode.PULL_FROM_END && yDiff > 0)) {
            Log.e(LOG_TAG, "Got yDiff > 0 or <0 when ACTION_MOVE event in onInterceptTouchEvent.");
            return false;
        }
        //???
        //mStartPoint
        if ((canChildScrollUp() && yDiff > 0) || (canChildScrollDown() && yDiff < 0)) {
            mStartPoint = y;
        }

        //
        if (yDiff > mTouchSlop) {
            //????
            if (canChildScrollUp() || mLastDirection == PullMode.PULL_FROM_END) {
                mIsBeingDragged = false;
                return false;
            }
            if (mMode.permitsPullFromStart()) {
                mLastMotionY = y;
                mIsBeingDragged = true;
                mLastDirection = PullMode.PULL_FROM_START;
                mCurrentMode = PullMode.PULL_FROM_START;
                Log.e(LOG_TAG, "Got yDiff > 0 when ACTION_MOVE event in onInterceptTouchEvent.");
                mProgress.setAlpha(STARTING_PROGRESS_ALPHA);
                Log.e(LOG_TAG,
                        "Got mProgress.setAlpha(STARTING_PROGRESS_ALPHA) in ACTION_MOVE event in onInterceptTouchEvent.");
            }
        }
        //
        else if (-yDiff > mTouchSlop) {
            //????
            if (canChildScrollDown() || mLastDirection == PullMode.PULL_FROM_START) {
                mIsBeingDragged = false;
                return false;
            }
            //????????
            if (!up && !down && !loadNoFull) {
                mIsBeingDragged = false;
                return false;
            }
            if (mMode.permitsPullFromEnd()) {
                mLastMotionY = y;
                mIsBeingDragged = true;
                mLastDirection = PullMode.PULL_FROM_END;
                mCurrentMode = PullMode.PULL_FROM_END;
                yDiff = -yDiff;
                mProgress.setAlpha(STARTING_PROGRESS_ALPHA);
                Log.e(LOG_TAG,
                        "Got mProgress.setAlpha(STARTING_PROGRESS_ALPHA) in ACTION_MOVE event in onInterceptTouchEvent.");
                Log.e(LOG_TAG, "Got yDiff < 0 when ACTION_MOVE event in onInterceptTouchEvent.");
            }
        }
        break;

    case MotionEventCompat.ACTION_POINTER_UP:
        onSecondaryPointerUp(ev);
        break;

    case MotionEvent.ACTION_UP:
    case MotionEvent.ACTION_CANCEL:
        Log.e(LOG_TAG, "Got ACTION_CANCEL event in onInterceptTouchEvent.");
        mIsBeingDragged = false;
        mActivePointerId = INVALID_POINTER;
        //v21 updown csdn version
        mLastDirection = PullMode.DISABLED;
        break;
    }

    return mIsBeingDragged;
}

From source file:com.hengye.swiperefresh.SwipeRefreshLayout.java

@Override
public boolean onTouchEvent(MotionEvent ev) {
    final int action = MotionEventCompat.getActionMasked(ev);
    int pointerIndex = -1;

    if (mReturningToStart && action == MotionEvent.ACTION_DOWN) {
        mReturningToStart = false;/* w ww  .  jav a2  s. co m*/
    }

    if (!isEnabled() || !isRefreshEnable() || mReturningToStart || canChildScrollUp()
            || mNestedScrollInProgress) {
        // Fail fast if we're not in a state where a swipe is possible
        return false;
    }

    switch (action) {
    case MotionEvent.ACTION_DOWN:
        mActivePointerId = MotionEventCompat.getPointerId(ev, 0);
        mIsBeingDragged = false;
        break;

    case MotionEvent.ACTION_MOVE: {
        pointerIndex = MotionEventCompat.findPointerIndex(ev, mActivePointerId);
        if (pointerIndex < 0) {
            Log.e(LOG_TAG, "Got ACTION_MOVE event but have an invalid active pointer id.");
            return false;
        }

        final float y = MotionEventCompat.getY(ev, pointerIndex);
        final float overscrollTop = (y - mInitialMotionY) * DRAG_RATE;
        if (mIsBeingDragged) {
            if (overscrollTop > 0) {
                moveSpinner(overscrollTop);
            } else {
                return false;
            }
        }
        break;
    }
    case MotionEventCompat.ACTION_POINTER_DOWN: {
        pointerIndex = MotionEventCompat.getActionIndex(ev);
        if (pointerIndex < 0) {
            Log.e(LOG_TAG, "Got ACTION_POINTER_DOWN event but have an invalid action index.");
            return false;
        }
        mActivePointerId = MotionEventCompat.getPointerId(ev, pointerIndex);
        break;
    }

    case MotionEventCompat.ACTION_POINTER_UP:
        onSecondaryPointerUp(ev);
        break;

    case MotionEvent.ACTION_UP: {
        pointerIndex = MotionEventCompat.findPointerIndex(ev, mActivePointerId);
        if (pointerIndex < 0) {
            Log.e(LOG_TAG, "Got ACTION_UP event but don't have an active pointer id.");
            return false;
        }

        final float y = MotionEventCompat.getY(ev, pointerIndex);
        final float overscrollTop = (y - mInitialMotionY) * DRAG_RATE;
        mIsBeingDragged = false;
        finishSpinner(overscrollTop);
        mActivePointerId = INVALID_POINTER;
        return false;
    }
    case MotionEvent.ACTION_CANCEL:
        return false;
    }

    return true;
}

From source file:com.mmt.widget.ViewDragHelper.java

/**
 * Process a touch event received by the parent view. This method will
 * dispatch callback events as needed before returning. The parent view's
 * onTouchEvent implementation should call this.
 *
 * @param ev The touch event received by the parent view
 *//*  w w w.  j  a v  a 2s .com*/
public void processTouchEvent(MotionEvent ev) {
    final int action = MotionEventCompat.getActionMasked(ev);
    final int actionIndex = MotionEventCompat.getActionIndex(ev);

    if (action == MotionEvent.ACTION_DOWN) {
        // Reset things for a new event stream, just in case we didn't get
        // the whole previous stream.
        cancel();
    }

    if (mVelocityTracker == null) {
        mVelocityTracker = VelocityTracker.obtain();
    }
    mVelocityTracker.addMovement(ev);

    switch (action) {
    case MotionEvent.ACTION_DOWN: {
        final float x = ev.getX();
        final float y = ev.getY();
        final int pointerId = MotionEventCompat.getPointerId(ev, 0);
        final View toCapture = findTopChildUnder((int) x, (int) y);

        saveInitialMotion(x, y, pointerId);

        // Since the parent is already directly processing this touch
        // event,
        // there is no reason to delay for a slop before dragging.
        // Start immediately if possible.
        tryCaptureViewForDrag(toCapture, pointerId);

        final int edgesTouched = mInitialEdgesTouched[pointerId];
        if ((edgesTouched & mTrackingEdges) != 0) {
            mCallback.onEdgeTouched(edgesTouched & mTrackingEdges, pointerId);
        }
        break;
    }

    case MotionEventCompat.ACTION_POINTER_DOWN: {
        final int pointerId = MotionEventCompat.getPointerId(ev, actionIndex);
        final float x = MotionEventCompat.getX(ev, actionIndex);
        final float y = MotionEventCompat.getY(ev, actionIndex);

        saveInitialMotion(x, y, pointerId);

        // A ViewDragHelper can only manipulate one view at a time.
        if (mDragState == STATE_IDLE) {
            // If we're idle we can do anything! Treat it like a normal
            // down
            // event.

            final View toCapture = findTopChildUnder((int) x, (int) y);
            tryCaptureViewForDrag(toCapture, pointerId);

            final int edgesTouched = mInitialEdgesTouched[pointerId];
            if ((edgesTouched & mTrackingEdges) != 0) {
                mCallback.onEdgeTouched(edgesTouched & mTrackingEdges, pointerId);
            }
        } else if (isCapturedViewUnder((int) x, (int) y)) {
            // We're still tracking a captured view. If the same view is
            // under this
            // point, we'll swap to controlling it with this pointer
            // instead.
            // (This will still work if we're "catching" a settling
            // view.)

            tryCaptureViewForDrag(mCapturedView, pointerId);
        }
        break;
    }

    case MotionEvent.ACTION_MOVE: {
        if (mDragState == STATE_DRAGGING) {
            final int index = MotionEventCompat.findPointerIndex(ev, mActivePointerId);
            final float x = MotionEventCompat.getX(ev, index);
            final float y = MotionEventCompat.getY(ev, index);
            final int idx = (int) (x - mLastMotionX[mActivePointerId]);
            final int idy = (int) (y - mLastMotionY[mActivePointerId]);

            dragTo(mCapturedView.getLeft() + idx, mCapturedView.getTop() + idy, idx, idy);

            saveLastMotion(ev);
        } else {
            // Check to see if any pointer is now over a draggable view.
            final int pointerCount = MotionEventCompat.getPointerCount(ev);
            for (int i = 0; i < pointerCount; i++) {
                final int pointerId = MotionEventCompat.getPointerId(ev, i);
                final float x = MotionEventCompat.getX(ev, i);
                final float y = MotionEventCompat.getY(ev, i);
                final float dx = x - mInitialMotionX[pointerId];
                final float dy = y - mInitialMotionY[pointerId];

                reportNewEdgeDrags(dx, dy, pointerId);
                if (mDragState == STATE_DRAGGING) {
                    // Callback might have started an edge drag.
                    break;
                }

                final View toCapture = findTopChildUnder((int) x, (int) y);
                if (checkTouchSlop(toCapture, dx, dy) && tryCaptureViewForDrag(toCapture, pointerId)) {
                    break;
                }
            }
            saveLastMotion(ev);
        }
        break;
    }

    case MotionEventCompat.ACTION_POINTER_UP: {
        final int pointerId = MotionEventCompat.getPointerId(ev, actionIndex);
        if (mDragState == STATE_DRAGGING && pointerId == mActivePointerId) {
            // Try to find another pointer that's still holding on to
            // the
            // captured view.
            int newActivePointer = INVALID_POINTER;
            final int pointerCount = MotionEventCompat.getPointerCount(ev);
            for (int i = 0; i < pointerCount; i++) {
                final int id = MotionEventCompat.getPointerId(ev, i);
                if (id == mActivePointerId) {
                    // This one's going away, skip.
                    continue;
                }

                final float x = MotionEventCompat.getX(ev, i);
                final float y = MotionEventCompat.getY(ev, i);
                if (findTopChildUnder((int) x, (int) y) == mCapturedView
                        && tryCaptureViewForDrag(mCapturedView, id)) {
                    newActivePointer = mActivePointerId;
                    break;
                }
            }

            if (newActivePointer == INVALID_POINTER) {
                // We didn't find another pointer still touching the
                // view,
                // release it.
                releaseViewForPointerUp();
            }
        }
        clearMotionHistory(pointerId);
        break;
    }

    case MotionEvent.ACTION_UP: {
        if (mDragState == STATE_DRAGGING) {
            releaseViewForPointerUp();
        }
        cancel();
        break;
    }

    case MotionEvent.ACTION_CANCEL: {
        if (mDragState == STATE_DRAGGING) {
            dispatchViewReleased(0, 0);
        }
        cancel();
        break;
    }
    }
}

From source file:com.shine.demo.viewpager.DirectionalViewPager.java

@Override
public boolean onTouchEvent(MotionEvent ev) {

    if (ev.getAction() == MotionEvent.ACTION_DOWN && ev.getEdgeFlags() != 0) {
        // Don't handle edge touches immediately -- they may actually belong to one of our
        // descendants.
        return false;
    }//from w  ww .  j a  v a 2s .  c  o  m

    if (mAdapter == null || mAdapter.getCount() == 0) {
        // Nothing to present or scroll; nothing to touch.
        return false;
    }

    if (mVelocityTracker == null) {
        mVelocityTracker = VelocityTracker.obtain();
    }
    mVelocityTracker.addMovement(ev);

    final int action = ev.getAction();

    switch (action & MotionEventCompat.ACTION_MASK) {
    case MotionEvent.ACTION_DOWN: {
        /*
         * If being flinged and user touches, stop the fling. isFinished
         * will be false if being flinged.
         */
        completeScroll();

        // Remember where the motion event started
        if (mOrientation == HORIZONTAL) {
            mLastMotionX = mInitialMotion = ev.getX();
        } else {
            mLastMotionY = mInitialMotion = ev.getY();
        }
        mActivePointerId = MotionEventCompat.getPointerId(ev, 0);
        break;
    }
    case MotionEvent.ACTION_MOVE:
        if (!mIsBeingDragged) {
            final int pointerIndex = MotionEventCompat.findPointerIndex(ev, mActivePointerId);
            final float x = MotionEventCompat.getX(ev, pointerIndex);
            final float y = MotionEventCompat.getY(ev, pointerIndex);
            final float xDiff = Math.abs(x - mLastMotionX);
            final float yDiff = Math.abs(y - mLastMotionY);
            float primaryDiff;
            float secondaryDiff;

            if (mOrientation == HORIZONTAL) {
                primaryDiff = xDiff;
                secondaryDiff = yDiff;
            } else {
                primaryDiff = yDiff;
                secondaryDiff = xDiff;
            }

            if (DEBUG)
                Log.v(TAG, "Moved x to " + x + "," + y + " diff=" + xDiff + "," + yDiff);
            if (primaryDiff > mTouchSlop && primaryDiff > secondaryDiff) {
                if (DEBUG)
                    Log.v(TAG, "Starting drag!");
                mIsBeingDragged = true;
                if (mOrientation == HORIZONTAL) {
                    mLastMotionX = x;
                } else {
                    mLastMotionY = y;
                }
                setScrollState(SCROLL_STATE_DRAGGING);
                setScrollingCacheEnabled(true);
            }
        }
        if (mIsBeingDragged) {
            // Scroll to follow the motion event
            final int activePointerIndex = MotionEventCompat.findPointerIndex(ev, mActivePointerId);
            final float x = MotionEventCompat.getX(ev, activePointerIndex);
            final float y = MotionEventCompat.getY(ev, activePointerIndex);

            int size;
            float scroll;

            if (mOrientation == HORIZONTAL) {
                size = getWidth();
                scroll = getScrollX() + (mLastMotionX - x);
                mLastMotionX = x;
            } else {
                size = getHeight();
                scroll = getScrollY() + (mLastMotionY - y);
                mLastMotionY = y;
            }

            final float lowerBound = Math.max(0, (mCurItem - 1) * size);
            final float upperBound = Math.min(mCurItem + 1, mAdapter.getCount() - 1) * size;
            if (scroll < lowerBound) {
                scroll = lowerBound;
            } else if (scroll > upperBound) {
                scroll = upperBound;
            }
            if (mOrientation == HORIZONTAL) {
                // Don't lose the rounded component
                mLastMotionX += scroll - (int) scroll;
                scrollTo((int) scroll, getScrollY());
            } else {
                // Don't lose the rounded component
                mLastMotionY += scroll - (int) scroll;
                scrollTo(getScrollX(), (int) scroll);
            }
            if (mOnPageChangeListener != null
                    || (mOnPageChangeListeners != null && mOnPageChangeListeners.size() > 0)) {
                final int position = (int) scroll / size;
                final int positionOffsetPixels = (int) scroll % size;
                final float positionOffset = (float) positionOffsetPixels / size;

                if (mOnPageChangeListener != null) {
                    mOnPageChangeListener.onPageScrolled(position, positionOffset, positionOffsetPixels);
                }

                if (mOnPageChangeListeners != null) {
                    for (int i = 0, z = mOnPageChangeListeners.size(); i < z; i++) {
                        OnPageChangeListener listener = mOnPageChangeListeners.get(i);
                        if (listener != null) {
                            listener.onPageScrolled(position, positionOffset, positionOffsetPixels);
                        }
                    }
                }
            }
        }
        break;
    case MotionEvent.ACTION_UP:
        if (mIsBeingDragged) {
            final VelocityTracker velocityTracker = mVelocityTracker;
            velocityTracker.computeCurrentVelocity(1000, mMaximumVelocity);
            int initialVelocity;
            float lastMotion;
            int sizeOverThree;

            if (mOrientation == HORIZONTAL) {
                initialVelocity = (int) VelocityTrackerCompat.getXVelocity(velocityTracker, mActivePointerId);
                lastMotion = mLastMotionX;
                sizeOverThree = getWidth() / 3;
            } else {
                initialVelocity = (int) VelocityTrackerCompat.getYVelocity(velocityTracker, mActivePointerId);
                lastMotion = mLastMotionY;
                sizeOverThree = getHeight() / 3;
            }

            mPopulatePending = true;
            if ((Math.abs(initialVelocity) > mMinimumVelocity)
                    || Math.abs(mInitialMotion - lastMotion) >= sizeOverThree) {
                if (lastMotion > mInitialMotion) {
                    setCurrentItemInternal(mCurItem - 1, true, true);
                } else {
                    setCurrentItemInternal(mCurItem + 1, true, true);
                }
            } else {
                setCurrentItemInternal(mCurItem, true, true);
            }

            mActivePointerId = INVALID_POINTER;
            endDrag();
        }
        break;
    case MotionEvent.ACTION_CANCEL:
        if (mIsBeingDragged) {
            setCurrentItemInternal(mCurItem, true, true);
            mActivePointerId = INVALID_POINTER;
            endDrag();
        }
        break;
    case MotionEventCompat.ACTION_POINTER_DOWN: {
        final int index = MotionEventCompat.getActionIndex(ev);
        if (mOrientation == HORIZONTAL) {
            mLastMotionX = MotionEventCompat.getX(ev, index);
        } else {
            mLastMotionY = MotionEventCompat.getY(ev, index);
        }
        mActivePointerId = MotionEventCompat.getPointerId(ev, index);
        break;
    }
    case MotionEventCompat.ACTION_POINTER_UP:
        onSecondaryPointerUp(ev);
        final int index = MotionEventCompat.findPointerIndex(ev, mActivePointerId);
        if (mOrientation == HORIZONTAL) {
            mLastMotionX = MotionEventCompat.getX(ev, index);
        } else {
            mLastMotionY = MotionEventCompat.getY(ev, index);
        }
        break;
    }
    return true;
}

From source file:com.juyujuyu.SwipeLoadLayout.java

@Override
public boolean onTouchEvent(MotionEvent ev) {
    final int action = MotionEventCompat.getActionMasked(ev);
    int pointerIndex = -1;

    if (mReturningToStart && action == MotionEvent.ACTION_DOWN) {
        mReturningToStart = false;/*  ww  w.  j  ava2s.c o  m*/
    }

    if (!isEnabled() || mReturningToStart || mNestedScrollInProgress) {
        // Fail fast if we're not in a state where a swipe is possible
        return false;
    }

    switch (action) {
    case MotionEvent.ACTION_DOWN:
        mActivePointerId = MotionEventCompat.getPointerId(ev, 0);
        mIsBeingDragged = false;
        break;

    case MotionEvent.ACTION_MOVE: {
        pointerIndex = MotionEventCompat.findPointerIndex(ev, mActivePointerId);
        if (pointerIndex < 0) {
            Log.e(LOG_TAG, "Got ACTION_MOVE event but have an invalid active pointer id.");
            return false;
        }

        final float y = MotionEventCompat.getY(ev, pointerIndex);
        final float overscrollTop = (y - mInitialMotionY) * DRAG_RATE;
        if (mIsBeingDragged) {
            //                    if (overscrollTop > 0) {
            //                        moveSpinner(overscrollTop);
            //                    } else {
            //                        return false;
            //                    }
            moveSpinner(overscrollTop);
        }
        break;
    }
    case MotionEventCompat.ACTION_POINTER_DOWN: {
        pointerIndex = MotionEventCompat.getActionIndex(ev);
        if (pointerIndex < 0) {
            Log.e(LOG_TAG, "Got ACTION_POINTER_DOWN event but have an invalid action index.");
            return false;
        }
        mActivePointerId = MotionEventCompat.getPointerId(ev, pointerIndex);
        break;
    }

    case MotionEventCompat.ACTION_POINTER_UP:
        onSecondaryPointerUp(ev);
        break;

    case MotionEvent.ACTION_UP: {
        pointerIndex = MotionEventCompat.findPointerIndex(ev, mActivePointerId);
        if (pointerIndex < 0) {
            Log.e(LOG_TAG, "Got ACTION_UP event but don't have an active pointer id.");
            return false;
        }

        final float y = MotionEventCompat.getY(ev, pointerIndex);
        final float overscrollTop = (y - mInitialMotionY) * DRAG_RATE;
        mIsBeingDragged = false;
        finishSpinner(overscrollTop);
        mActivePointerId = INVALID_POINTER;
        return false;
    }
    case MotionEvent.ACTION_CANCEL:
        return false;
    }

    return true;
}

Example usage for android.support.v4.view MotionEventCompat ACTION_POINTER_UP

Introduction

Prototype

Document

Usage