Code example for MotionEvent

Methods: findPointerIndexgetActiongetPointerIdgetX, MotionEvent.getY

0
 
        private VelocityTracker mVelocityTracker;
        private boolean mIsDragging;
 
        float getActiveX(MotionEvent ev) {
            return ev.getX();
        } 
 
        float getActiveY(MotionEvent ev) {
            return ev.getY();
        } 
 
        public boolean isScaling() { 
            return false; 
        } 
 
        @Override 
        public boolean onTouchEvent(MotionEvent ev) {
            switch (ev.getAction()) {
                case MotionEvent.ACTION_DOWN: {
                    mVelocityTracker = VelocityTracker.obtain();
                    mVelocityTracker.addMovement(ev);
 
                    mLastTouchX = getActiveX(ev);
                    mLastTouchY = getActiveY(ev);
                    mIsDragging = false;
                    break; 
                } 
 
                case MotionEvent.ACTION_MOVE: {
                    final float x = getActiveX(ev);
                    final float y = getActiveY(ev);
                    final float dx = x - mLastTouchX, dy = y - mLastTouchY;
 
                    if (!mIsDragging) {
                        // Use Pythagoras to see if drag length is larger than 
                        // touch slop 
                        mIsDragging = FloatMath.sqrt((dx * dx) + (dy * dy)) >= mTouchSlop;
                    } 
 
                    if (mIsDragging) {
                        mListener.onDrag(dx, dy);
                        mLastTouchX = x;
                        mLastTouchY = y;
 
                        if (null != mVelocityTracker) {
                            mVelocityTracker.addMovement(ev);
                        } 
                    } 
                    break; 
                } 
 
                case MotionEvent.ACTION_CANCEL: {
                    // Recycle Velocity Tracker 
                    if (null != mVelocityTracker) {
                        mVelocityTracker.recycle();
                        mVelocityTracker = null;
                    } 
                    break; 
                } 
 
                case MotionEvent.ACTION_UP: {
                    if (mIsDragging) {
                        if (null != mVelocityTracker) {
                            mLastTouchX = getActiveX(ev);
                            mLastTouchY = getActiveY(ev);
 
                            // Compute velocity within the last 1000ms 
                            mVelocityTracker.addMovement(ev);
                            mVelocityTracker.computeCurrentVelocity(1000);
 
                            final float vX = mVelocityTracker.getXVelocity(), vY = mVelocityTracker.getYVelocity();
 
                            // If the velocity is greater than minVelocity, call 
                            // listener 
                            if (Math.max(Math.abs(vX), Math.abs(vY)) >= mMinimumVelocity) {
                                mListener.onFling(mLastTouchX, mLastTouchY, -vX, -vY);
                            } 
                        } 
                    } 
 
                    // Recycle Velocity Tracker 
                    if (null != mVelocityTracker) {
                        mVelocityTracker.recycle();
                        mVelocityTracker = null;
                    } 
                    break; 
                } 
            } 
 
            return true; 
        } 
    } 
 
    @TargetApi(5) 
    private static class EclairDetector extends CupcakeDetector { 
        private static final int INVALID_POINTER_ID = -1;
        private int mActivePointerId = INVALID_POINTER_ID;
        private int mActivePointerIndex = 0;
 
        public EclairDetector(Context context) {
            super(context);
        } 
 
        @Override 
        float getActiveX(MotionEvent ev) {
            try { 
                return ev.getX(mActivePointerIndex);
            } catch (Exception e) {
                return ev.getX();
            } 
        } 
 
        @Override 
        float getActiveY(MotionEvent ev) {
            try { 
                return ev.getY(mActivePointerIndex);
            } catch (Exception e) {
                return ev.getY();
            } 
        } 
 
        @Override 
        public boolean onTouchEvent(MotionEvent ev) {
            final int action = ev.getAction();
            switch (action & MotionEvent.ACTION_MASK) {
                case MotionEvent.ACTION_DOWN:
                    mActivePointerId = ev.getPointerId(0);
                    break; 
                case MotionEvent.ACTION_CANCEL:
                case MotionEvent.ACTION_UP:
                    mActivePointerId = INVALID_POINTER_ID;
                    break; 
                case MotionEvent.ACTION_POINTER_UP:
                    final int pointerIndex = (ev.getAction() & MotionEvent.ACTION_POINTER_INDEX_MASK) >> MotionEvent.ACTION_POINTER_INDEX_SHIFT;
                    final int pointerId = ev.getPointerId(pointerIndex);
                    if (pointerId == mActivePointerId) {
                        // This was our active pointer going up. Choose a new 
                        // active pointer and adjust accordingly. 
                        final int newPointerIndex = pointerIndex == 0 ? 1 : 0;
                        mActivePointerId = ev.getPointerId(newPointerIndex);
                        mLastTouchX = ev.getX(newPointerIndex);
                        mLastTouchY = ev.getY(newPointerIndex);
                    } 
                    break; 
            } 
 
            mActivePointerIndex = ev.findPointerIndex(mActivePointerId != INVALID_POINTER_ID ? mActivePointerId : 0);
            return super.onTouchEvent(ev);
        } 
    } 
 
    @TargetApi(8)