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

List of usage examples for android.support.v4.view MotionEventCompat getY

  1. HOME
  2. Java
  3. android
  4. android.support.v4.view.*
  5. MotionEventCompat
  6. getY

Introduction

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

Prototype

public static float getY(MotionEvent event, int pointerIndex)

Source Link

Document

Call MotionEvent#getY(int) .

Usage

From source file:com.google.blockly.android.ui.VirtualWorkspaceView.java

@Override
public boolean onTouchEvent(MotionEvent event) {
    mScaleGestureDetector.onTouchEvent(event);
    if (mScaleGestureDetector.isInProgress()) {
        // If the scale gesture detector is handling a scale-and-pan gesture, then exit here
        // since otherwise we would also be generating dragging events below.
        return true;
    }/*from  ww w  .  ja  v  a  2s  . c  o  m*/

    final int action = MotionEventCompat.getActionMasked(event);

    switch (action) {
    case MotionEvent.ACTION_DOWN: {
        clearFocus();
        mImeManager.hideSoftInputFromWindow(getWindowToken(), 0);

        if (mScrollable) {
            final int pointerIdx = MotionEventCompat.getActionIndex(event);
            mPanningPointerId = MotionEventCompat.getPointerId(event, pointerIdx);
            mPanningStart.set((int) MotionEventCompat.getX(event, pointerIdx),
                    (int) MotionEventCompat.getY(event, pointerIdx));
            mOriginalScrollX = getScrollX();
            mOriginalScrollY = getScrollY();
        }
        return true;
    }
    case MotionEvent.ACTION_MOVE: {
        if (mPanningPointerId != MotionEvent.INVALID_POINTER_ID) {
            final int pointerIdx = MotionEventCompat.findPointerIndex(event, mPanningPointerId);
            if (pointerIdx == -1) {
                // TODO: (#319) remove when we clean up multi-touch handling.
                Log.w(TAG, "Got an invalid pointer idx for the panning pointer.");
                return false;
            }
            scrollTo(mOriginalScrollX + mPanningStart.x - (int) MotionEventCompat.getX(event, pointerIdx),
                    mOriginalScrollY + mPanningStart.y - (int) MotionEventCompat.getY(event, pointerIdx));
            return true;
        } else {
            return false;
        }
    }
    case MotionEvent.ACTION_POINTER_UP: {
        // Some pointer went up - check whether it was the one used for panning.
        final int pointerIdx = MotionEventCompat.getActionIndex(event);
        final int pointerId = MotionEventCompat.getPointerId(event, pointerIdx);
        if (pointerId != mPanningPointerId) {
            return false;
        }
        // Pointer that went up was used for panning - treat like ACTION_UP.
        // FALLTHROUGH INTENDED.
    }
    case MotionEvent.ACTION_UP: {
        if (mPanningPointerId != MotionEvent.INVALID_POINTER_ID) {
            mPanningPointerId = MotionEvent.INVALID_POINTER_ID;
            return true;
        } else {
            return false;
        }
    }
    case MotionEvent.ACTION_CANCEL: {
        if (mPanningPointerId != MotionEvent.INVALID_POINTER_ID) {
            // When cancelled, reset to original scroll position.
            scrollTo(mOriginalScrollX, mOriginalScrollY);
            mPanningPointerId = MotionEvent.INVALID_POINTER_ID;
            return true;
        } else {
            return false;
        }
    }
    default: {
        break;
    }
    }

    return false;
}

From source file:com.gitstudy.rili.liarbry.CalendarLayout.java

@SuppressLint("ClickableViewAccessibility")
@Override//from w w w . ja  v  a2 s .c  om
public boolean onTouchEvent(MotionEvent event) {

    if (mDelegate.isShowYearSelectedLayout) {
        return false;
    }

    if (mContentView == null) {
        return false;
    }

    int action = event.getAction();
    float y = event.getY();
    mVelocityTracker.addMovement(event);
    switch (action) {
    case MotionEvent.ACTION_DOWN:

        int index = MotionEventCompat.getActionIndex(event);
        mActivePointerId = MotionEventCompat.getPointerId(event, index);
        mLastY = downY = y;
        return true;
    case MotionEventCompat.ACTION_POINTER_DOWN: {
        final int indexx = MotionEventCompat.getActionIndex(event);
        mActivePointerId = MotionEventCompat.getPointerId(event, indexx);
        if (mActivePointerId == 0) {
            //?? dy = y- mLastY == 0??
            mLastY = MotionEventCompat.getY(event, mActivePointerId);
        }
        break;
    }
    case MotionEvent.ACTION_MOVE:
        if (mGestureMode == GESTURE_MODE_DISABLED || mCalendarShowMode == CALENDAR_SHOW_MODE_ONLY_MONTH_VIEW
                || mCalendarShowMode == CALENDAR_SHOW_MODE_ONLY_WEEK_VIEW) {//????
            return false;
        }

        getPointerIndex(event, mActivePointerId);
        if (mActivePointerId == INVALID_POINTER) {
            //?mLastY?y????? dy== 0??
            mLastY = y;
            mActivePointerId = ACTIVE_POINTER;
        }

        float dy = y - mLastY;
        //?contentView?
        if (dy < 0 && mContentView.getTranslationY() == -mContentViewTranslateY) {
            //mContentView.onTouchEvent(event);
            showWeek();
            mLastY = y;
            return false;
        }
        hideWeek();

        //?contentView?
        if (dy > 0 && mContentView.getTranslationY() + dy >= 0) {
            mContentView.setTranslationY(0);
            translationViewPager();
            mLastY = y;
            return super.onTouchEvent(event);
        }

        //?contentView??contentView?
        if (dy < 0 && mContentView.getTranslationY() + dy <= -mContentViewTranslateY) {
            mContentView.setTranslationY(-mContentViewTranslateY);
            translationViewPager();
            mLastY = y;
            return super.onTouchEvent(event);
        }
        //?
        mContentView.setTranslationY(mContentView.getTranslationY() + dy);
        translationViewPager();
        mLastY = y;
        break;
    case MotionEvent.ACTION_CANCEL:

    case MotionEvent.ACTION_POINTER_UP:
        int pointerIndex = getPointerIndex(event, mActivePointerId);
        if (mActivePointerId == INVALID_POINTER)
            break;
        mLastY = MotionEventCompat.getY(event, pointerIndex);
        break;
    case MotionEvent.ACTION_UP:

        final VelocityTracker velocityTracker = mVelocityTracker;
        velocityTracker.computeCurrentVelocity(1000, mMaximumVelocity);
        float mYVelocity = velocityTracker.getYVelocity();
        if (mContentView.getTranslationY() == 0 || mContentView.getTranslationY() == mContentViewTranslateY) {
            break;
        }
        if (Math.abs(mYVelocity) >= 800) {
            if (mYVelocity < 0) {
                shrink();
            } else {
                expand();
            }
            return super.onTouchEvent(event);
        }
        if (event.getY() - downY > 0) {
            expand();
        } else {
            shrink();
        }
        break;
    }
    return super.onTouchEvent(event);
}

From source file:chinanurse.cn.nurse.list.WaveSwipeRefreshLayout.java

private boolean onMoveTouchEvent(@NonNull MotionEvent event, int pointerIndex) {
    if (mIsBeingDropped) {
        return false;
    }//w w  w. ja v a2s.  co  m

    final float y = MotionEventCompat.getY(event, pointerIndex);
    final float diffY = y - mFirstTouchDownPointY;
    final float overScrollTop = diffY * DRAGGING_WEIGHT;

    if (overScrollTop < 0) {
        mCircleView.showArrow(false);
        return false;
    }

    final DisplayMetrics metrics = getResources().getDisplayMetrics();

    float originalDragPercent = overScrollTop / (DEFAULT_CIRCLE_TARGET * metrics.density);
    float dragPercent = Math.min(1f, originalDragPercent);
    float adjustedPercent = (float) Math.max(dragPercent - .4, 0) * 5 / 3;

    // 0f...2f
    float tensionSlingshotPercent = (originalDragPercent > 3f) ? 2f
            : (originalDragPercent > 1f) ? originalDragPercent - 1f : 0;
    float tensionPercent = (4f - tensionSlingshotPercent) * tensionSlingshotPercent / 8f;

    mCircleView.showArrow(true);
    reInitCircleView();

    if (originalDragPercent < 1f) {
        float strokeStart = adjustedPercent * .8f;
        mCircleView.setProgressStartEndTrim(0f, Math.min(MAX_PROGRESS_ROTATION_RATE, strokeStart));
        mCircleView.setArrowScale(Math.min(1f, adjustedPercent));
    }

    float rotation = (-0.25f + .4f * adjustedPercent + tensionPercent * 2) * .5f;
    mCircleView.setProgressRotation(rotation);
    mCircleView.setTranslationY(mWaveView.getCurrentCircleCenterY());

    float seed = diffY / Math.min(getMeasuredWidth(), getMeasuredHeight());
    float firstBounds = seed * (5f - 2 * seed) / 3.5f;
    float secondBounds = firstBounds - VERTICAL_DRAG_THRESHOLD.FIRST.val;
    float finalBounds = (firstBounds - VERTICAL_DRAG_THRESHOLD.SECOND.val) / 5;

    if (firstBounds < VERTICAL_DRAG_THRESHOLD.FIRST.val) {
        // draw a wave and not draw a circle
        onBeginPhase(firstBounds);
    } else if (firstBounds < VERTICAL_DRAG_THRESHOLD.SECOND.val) {
        // draw a circle with a wave
        onAppearPhase(firstBounds, secondBounds);
    } else if (firstBounds < VERTICAL_DRAG_THRESHOLD.THIRD.val) {
        // draw a circle with expanding a wave
        onExpandPhase(firstBounds, secondBounds, finalBounds);
    } else {
        // stop to draw a wave and drop a circle
        onDropPhase();
    }

    return !mIsBeingDropped;
}

From source file:com.conduit.plastic.widget.NestedWebView.java

@Override
public boolean onTouchEvent(MotionEvent ev) {
    if (this.position == ScrollStateChangedListener.ScrollState.MIDDLE) {
        switch (ev.getAction()) {
        case MotionEvent.ACTION_DOWN: {
            this.mIsBeingDragged = false;
            this.mActivePointerId = MotionEventCompat.getPointerId(ev, 0);
            this.startNestedScroll(2);
            break;
        }//ww w  .ja v  a  2 s .  com
        case MotionEvent.ACTION_UP:
        case MotionEvent.ACTION_CANCEL: {
            this.endTouch();
            break;
        }
        }
        super.onTouchEvent(ev);
        return true;
    }
    final int actionMasked = MotionEventCompat.getActionMasked(ev);
    initVelocityTrackerIfNotExists();
    MotionEvent vtev = MotionEvent.obtain(ev);
    final int index = MotionEventCompat.getActionIndex(ev);
    if (actionMasked == MotionEvent.ACTION_DOWN) {
        mNestedYOffset = 0;
    }
    vtev.offsetLocation(0, mNestedYOffset);
    this.consumedY = 0;
    this.direction = 0;
    boolean onTouchEvent = false;
    switch (actionMasked) {
    case MotionEvent.ACTION_DOWN: {
        // Remember where the motion event started
        onTouchEvent = super.onTouchEvent(ev);
        mLastMotionY = (int) (ev.getY() + 0.5f);
        mActivePointerId = MotionEventCompat.getPointerId(ev, 0);
        this.preY = vtev.getY();
        this.mIsBeingDragged = false;
        startNestedScroll(ViewCompat.SCROLL_AXIS_VERTICAL);
        break;
    }
    case MotionEventCompat.ACTION_POINTER_DOWN: {
        onTouchEvent = super.onTouchEvent(ev);
        mLastMotionY = (int) (MotionEventCompat.getY(ev, index) + 0.5f);
        mActivePointerId = MotionEventCompat.getPointerId(ev, index);
        break;
    }
    case MotionEvent.ACTION_MOVE:
        final int activePointerIndex = MotionEventCompat.findPointerIndex(ev, mActivePointerId);
        if (activePointerIndex == -1) {
            Log.e(TAG, "Invalid pointerId=" + mActivePointerId + " in onTouchEvent");
            break;
        }
        if (!mIsBeingDragged && Math.abs(vtev.getY() - this.preY) > mTouchSlop) {
            final ViewParent parent = getParent();
            if (parent != null) {
                parent.requestDisallowInterceptTouchEvent(true);
            }
            mIsBeingDragged = true;
        }
        //                if(!mIsBeingDragged){
        //                    setLongClickEnable(true);
        //                }
        final int y = (int) (MotionEventCompat.getY(ev, activePointerIndex) + 0.5f);
        Log.i(TAG, "mLastMotionY=====" + mLastMotionY);
        Log.i(TAG, "YYYYYYY=====" + y);
        int deltaY = mLastMotionY - y;

        if (deltaY != 0) {
            this.direction = this.directionDetector.getDirection(deltaY, true, this.scrollStateChangedListener);
        }
        if (dispatchNestedPreScroll(0, deltaY, mScrollConsumed, mScrollOffset)) {
            deltaY -= mScrollConsumed[1];
            vtev.offsetLocation(0, mScrollOffset[1]);
            mNestedYOffset += mScrollOffset[1];
        }
        if (mIsBeingDragged) {
            //                    setJavaScriptEnable(true);
            // Scroll to follow the motion event
            mLastMotionY = y - mScrollOffset[1];
            Log.i(TAG, "deltaY===" + deltaY);
            Log.i(TAG, "this.consumedY===" + this.consumedY);
            final int unconsumedY = deltaY - this.consumedY;

            Log.i(TAG, " child consumed = " + this.mScrollConsumed[1] + " un_consumed = " + unconsumedY
                    + " position = " + this.position + " direction = " + this.direction);
            onTouchEvent = super.onTouchEvent(ev);
            if (this.position == ScrollStateChangedListener.ScrollState.MIDDLE) {
                return true;
            }
            switch (this.direction) {
            case 1: {
                if ((this.position != ScrollStateChangedListener.ScrollState.BOTTOM)
                        && (this.contentHeight != this.webviewHeight)) {
                    scrollBy(0, unconsumedY);
                    break;
                }
                Log.i(TAG, "1111111consumedY===" + consumedY + "  unconsumedY==" + unconsumedY);
                if (dispatchNestedScroll(0, this.consumedY, 0, unconsumedY, this.mScrollOffset)) {
                    vtev.offsetLocation(0.0F, this.mScrollOffset[1]);
                    this.mNestedYOffset += this.mScrollOffset[1];
                    this.mLastMotionY -= this.mScrollOffset[1];
                }
            }
                break;
            case 2:
                if ((this.position == ScrollStateChangedListener.ScrollState.TOP)
                        || (this.contentHeight == this.webviewHeight)) {
                    Log.i(TAG, "2222222consumedY===" + consumedY + "  unconsumedY==" + unconsumedY);
                    if (dispatchNestedScroll(0, this.consumedY, 0, unconsumedY, this.mScrollOffset)) {
                        vtev.offsetLocation(0.0F, this.mScrollOffset[1]);
                        this.mNestedYOffset += this.mScrollOffset[1];
                        this.mLastMotionY -= this.mScrollOffset[1];
                    }
                } else {
                    scrollBy(0, unconsumedY);
                }
                break;
            default:
                break;
            }
        }
        break;
    case MotionEvent.ACTION_CANCEL:
        onTouchEvent = super.onTouchEvent(ev);
        break;
    case MotionEvent.ACTION_UP:
        onTouchEvent = super.onTouchEvent(ev);
        if (mIsBeingDragged) {
            final VelocityTracker velocityTracker = mVelocityTracker;
            velocityTracker.computeCurrentVelocity(1000, mMaximumVelocity);
            int initialVelocity = (int) VelocityTrackerCompat.getYVelocity(velocityTracker, mActivePointerId);
            if ((Math.abs(initialVelocity) > mMinimumVelocity)) {
                flingWithNestedDispatch(-initialVelocity);
            }
        }
        mActivePointerId = INVALID_POINTER;
        endTouch();
        break;

    case MotionEventCompat.ACTION_POINTER_UP:
        onTouchEvent = super.onTouchEvent(ev);
        onSecondaryPointerUp(ev);
        mLastMotionY = (int) (MotionEventCompat.getY(ev,
                MotionEventCompat.findPointerIndex(ev, mActivePointerId)) + 0.5F);
        break;
    }
    if (mVelocityTracker != null) {
        mVelocityTracker.addMovement(vtev);
    }
    vtev.recycle();
    return onTouchEvent;
}

From source file:de.uni_weimar.mheinz.androidtouchscope.display.HandleView.java

private boolean touchSelectCursor(MotionEvent event) {
    final int pointerIndex = MotionEventCompat.getActionIndex(event);
    final float x = MotionEventCompat.getX(event, pointerIndex);
    final float y = MotionEventCompat.getY(event, pointerIndex);

    PointF point = getCircleCenter();/*from   ww w . jav  a2s. co m*/

    boolean selected = false;
    if (x >= point.x - HANDLE_BREADTH && x <= point.x + HANDLE_BREADTH && y >= point.y - HANDLE_BREADTH
            && y <= point.y + HANDLE_BREADTH) {
        selected = true;
        //  invalidate();
    }

    return selected;
}

From source file:com.google.blockly.android.ui.AbstractBlockView.java

@Override
public void getTouchLocationOnScreen(MotionEvent event, @Size(2) int[] locationOut) {
    int pointerId = MotionEventCompat.getPointerId(event, MotionEventCompat.getActionIndex(event));
    int pointerIdx = MotionEventCompat.findPointerIndex(event, pointerId);
    float offsetX = MotionEventCompat.getX(event, pointerIdx);
    float offsetY = MotionEventCompat.getY(event, pointerIdx);

    // Get local screen coordinates.
    getLocationOnScreen(locationOut);/* www.  j  a v  a 2 s  .c  o  m*/

    // add the scaled offset.
    if (mWorkspaceView != null) {
        float scale = mWorkspaceView.getScaleX();
        offsetX = offsetX * scale;
        offsetY = offsetY * scale;
    }
    locationOut[0] += (int) offsetX;
    locationOut[1] += (int) offsetY;
}

From source file:com.kaplandroid.colorbook.SlidingLayer.java

@Override
public boolean onInterceptTouchEvent(MotionEvent ev) {

    if (!mEnabled) {
        return false;
    }//from w  w w  .ja  v a2 s . com

    final int action = ev.getAction() & MotionEventCompat.ACTION_MASK;

    if (action == MotionEvent.ACTION_CANCEL || action == MotionEvent.ACTION_UP) {
        mIsDragging = false;
        mIsUnableToDrag = false;
        mActivePointerId = INVALID_POINTER;
        if (mVelocityTracker != null) {
            mVelocityTracker.recycle();
            mVelocityTracker = null;
        }
        return false;
    }

    if (action != MotionEvent.ACTION_DOWN) {
        if (mIsDragging) {
            return true;
        } else if (mIsUnableToDrag) {
            return false;
        }
    }

    switch (action) {
    case MotionEvent.ACTION_MOVE:
        final int activePointerId = mActivePointerId;
        if (activePointerId == INVALID_POINTER) {
            break;
        }

        final int pointerIndex = MotionEventCompat.findPointerIndex(ev, activePointerId);
        if (pointerIndex == -1) {
            mActivePointerId = INVALID_POINTER;
            break;
        }

        final float x = MotionEventCompat.getX(ev, pointerIndex);
        final float dx = x - mLastX;
        final float xDiff = Math.abs(dx);
        final float y = MotionEventCompat.getY(ev, pointerIndex);
        final float yDiff = Math.abs(y - mLastY);
        if (xDiff > mTouchSlop && xDiff > yDiff && allowDraging(dx)) {
            mIsDragging = true;
            mLastX = x;
            setDrawingCacheEnabled(true);
        } else if (yDiff > mTouchSlop) {
            mIsUnableToDrag = true;
        }
        break;

    case MotionEvent.ACTION_DOWN:
        mActivePointerId = ev.getAction() & (Build.VERSION.SDK_INT >= 8 ? MotionEvent.ACTION_POINTER_INDEX_MASK
                : MotionEvent.ACTION_POINTER_INDEX_MASK);
        mLastX = mInitialX = MotionEventCompat.getX(ev, mActivePointerId);
        mLastY = MotionEventCompat.getY(ev, mActivePointerId);
        if (allowSlidingFromHere(ev)) {
            mIsDragging = false;
            mIsUnableToDrag = false;
            // If nobody else got the focus we use it to close the layer
            return super.onInterceptTouchEvent(ev);
        } else {
            mIsUnableToDrag = true;
        }
        break;
    case MotionEventCompat.ACTION_POINTER_UP:
        onSecondaryPointerUp(ev);
        break;
    }

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

    return mIsDragging;
}

From source file:com.irontec.jaigiro.widgets.StaggeredGridView.java

@Override
public boolean onInterceptTouchEvent(MotionEvent ev) {
    mVelocityTracker.addMovement(ev);//  w w  w.  ja v a  2s . com
    final int action = ev.getAction() & MotionEventCompat.ACTION_MASK;
    switch (action) {
    case MotionEvent.ACTION_DOWN:
        mVelocityTracker.clear();
        mScroller.abortAnimation();
        mLastTouchY = ev.getY();
        mActivePointerId = MotionEventCompat.getPointerId(ev, 0);
        mTouchRemainderY = 0;
        if (mTouchMode == TOUCH_MODE_FLINGING) {
            // Catch!
            // Stopped a fling. It is a scroll.
            setTouchMode(TOUCH_MODE_DRAGGING);

            return true;
        }
        break;

    case MotionEvent.ACTION_MOVE: {
        final int index = MotionEventCompat.findPointerIndex(ev, mActivePointerId);
        if (index < 0) {
            Log.e(TAG, "onInterceptTouchEvent could not find pointer with id " + mActivePointerId
                    + " - did StaggeredGridView receive an inconsistent " + "event stream?");
            return false;
        }
        final float y = MotionEventCompat.getY(ev, index);
        final float dy = y - mLastTouchY + mTouchRemainderY;
        final int deltaY = (int) dy;
        mTouchRemainderY = dy - deltaY;

        if (Math.abs(dy) > mTouchSlop) {
            setTouchMode(TOUCH_MODE_DRAGGING);
            return true;
        }
    }
    }

    return false;
}

From source file:com.coco.slidinguppanel.SlidingUpPanel.java

@Override
public boolean onInterceptTouchEvent(MotionEvent ev) {
    // This method JUST determines whether we want to intercept the motion.
    // If we return true, onMotionEvent will be called and we do the actual
    // scrolling there.
    final int action = MotionEventCompat.getActionMasked(ev);

    // Always take care of the touch gesture being complete.
    if (action == MotionEvent.ACTION_CANCEL || action == MotionEvent.ACTION_UP) {
        // Release the drag.
        DEBUG_LOG("Intercept done!");
        endDrag();/*from ww  w. j  a va  2  s  . com*/
        return false;
    }

    // Nothing more to do here if we have decided whether or not we are dragging.
    if (action != MotionEvent.ACTION_DOWN) {
        if (mIsBeingDragged) {
            DEBUG_LOG("Intercept returning true!");
            return true;
        }
        if (mIsUnableToDrag) {
            DEBUG_LOG("Intercept returning false!");
            return false;
        }
    }

    // Check whether the user has moved far enough from his original down touch.
    switch (action) {
    case MotionEvent.ACTION_DOWN: {
        onTouchDown(ev, true);
        DEBUG_LOG("***Down at " + mLastMotionX + "," + mLastMotionY + " mIsBeingDragged=" + mIsBeingDragged
                + " mIsUnableToDrag=" + mIsUnableToDrag);
        break;
    }
    case MotionEvent.ACTION_MOVE: {
        final int activePointerId = mActivePointerId;
        if (activePointerId == INVALID_POINTER) {
            // If we don't have a valid id, the touch down wasn't on content.
            break;
        }
        final int pointerIndex = MotionEventCompat.findPointerIndex(ev, activePointerId);
        final float x = MotionEventCompat.getX(ev, pointerIndex);
        final float y = MotionEventCompat.getY(ev, pointerIndex);
        final float xDiff = Math.abs(x - mInitialMotionX);
        final float yDiff = Math.abs(y - mInitialMotionY);
        DEBUG_LOG("***Moved to " + x + "," + y + " diff=" + xDiff + "," + yDiff);
        onTouchMove(x, y, xDiff, yDiff, true);
        break;
    }
    case MotionEvent.ACTION_POINTER_UP:
        onTouchPointerUp(ev);
        break;
    }

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

    // The only time we want to intercept motion events is if we are in the drag mode.
    return mIsBeingDragged;
}

From source file:cn.ieclipse.af.view.StaggeredGridView.java

@Override
public boolean onTouchEvent(MotionEvent ev) {
    mVelocityTracker.addMovement(ev);/*from  w  w  w.  j  a va 2  s. co m*/
    final int action = ev.getAction() & MotionEventCompat.ACTION_MASK;
    switch (action) {
    case MotionEvent.ACTION_DOWN:
        mVelocityTracker.clear();
        mScroller.abortAnimation();
        mLastTouchY = ev.getY();
        mActivePointerId = MotionEventCompat.getPointerId(ev, 0);
        mTouchRemainderY = 0;
        break;

    case MotionEvent.ACTION_MOVE: {
        final int index = MotionEventCompat.findPointerIndex(ev, mActivePointerId);
        if (index < 0) {
            Log.e(TAG, "onInterceptTouchEvent could not find pointer with id " + mActivePointerId
                    + " - did StaggeredGridView receive an inconsistent " + "event stream?");
            return false;
        }
        final float y = MotionEventCompat.getY(ev, index);
        final float dy = y - mLastTouchY + mTouchRemainderY;
        final int deltaY = (int) dy;
        mTouchRemainderY = dy - deltaY;

        if (Math.abs(dy) > mTouchSlop) {
            mTouchMode = TOUCH_MODE_DRAGGING;
        }

        if (mTouchMode == TOUCH_MODE_DRAGGING) {
            mLastTouchY = y;

            if (!trackMotionScroll(deltaY, true)) {
                // Break fling velocity if we impacted an edge.
                mVelocityTracker.clear();
            }
        }
    }
        break;

    case MotionEvent.ACTION_CANCEL:
        mTouchMode = TOUCH_MODE_IDLE;
        break;

    case MotionEvent.ACTION_UP: {
        mVelocityTracker.computeCurrentVelocity(1000, mMaximumVelocity);
        final float velocity = VelocityTrackerCompat.getYVelocity(mVelocityTracker, mActivePointerId);
        if (Math.abs(velocity) > mFlingVelocity) { // TODO
            mTouchMode = TOUCH_MODE_FLINGING;
            mScroller.fling(0, 0, 0, (int) velocity, 0, 0, Integer.MIN_VALUE, Integer.MAX_VALUE);
            mLastTouchY = 0;
            ViewCompat.postInvalidateOnAnimation(this);
        } else {
            mTouchMode = TOUCH_MODE_IDLE;
        }

    }
        break;
    }
    return true;
}