Exemple #1
0
        /// <summary>
        /// Analyzes the given motion event and if applicable triggers the
        /// appropriate callbacks on the
        /// <see cref="OnGestureListener">OnGestureListener</see>
        /// supplied.
        /// </summary>
        /// <param name="ev">The current motion event.</param>
        /// <returns>
        /// true if the
        /// <see cref="OnGestureListener">OnGestureListener</see>
        /// consumed the event,
        /// else false.
        /// </returns>
        public virtual bool onTouchEvent(android.view.MotionEvent ev)
        {
            if (mInputEventConsistencyVerifier != null)
            {
                mInputEventConsistencyVerifier.onTouchEvent(ev, 0);
            }
            int   action = ev.getAction();
            float y      = ev.getY();
            float x      = ev.getX();

            if (mVelocityTracker == null)
            {
                mVelocityTracker = android.view.VelocityTracker.obtain();
            }
            mVelocityTracker.addMovement(ev);
            bool handled = false;

            switch (action & android.view.MotionEvent.ACTION_MASK)
            {
            case android.view.MotionEvent.ACTION_POINTER_DOWN:
            {
                if (mIgnoreMultitouch)
                {
                    // Multitouch event - abort.
                    cancel();
                }
                break;
            }

            case android.view.MotionEvent.ACTION_POINTER_UP:
            {
                // Ending a multitouch gesture and going back to 1 finger
                if (mIgnoreMultitouch && ev.getPointerCount() == 2)
                {
                    int index = (((action & android.view.MotionEvent.ACTION_POINTER_INDEX_MASK) >> android.view.MotionEvent
                                  .ACTION_POINTER_INDEX_SHIFT) == 0) ? 1 : 0;
                    mLastMotionX = ev.getX(index);
                    mLastMotionY = ev.getY(index);
                    mVelocityTracker.recycle();
                    mVelocityTracker = android.view.VelocityTracker.obtain();
                }
                break;
            }

            case android.view.MotionEvent.ACTION_DOWN:
            {
                if (mDoubleTapListener != null)
                {
                    bool hadTapMessage = mHandler.hasMessages(TAP);
                    if (hadTapMessage)
                    {
                        mHandler.removeMessages(TAP);
                    }
                    if ((mCurrentDownEvent != null) && (mPreviousUpEvent != null) && hadTapMessage &&
                        isConsideredDoubleTap(mCurrentDownEvent, mPreviousUpEvent, ev))
                    {
                        // This is a second tap
                        mIsDoubleTapping = true;
                        // Give a callback with the first tap of the double-tap
                        handled |= mDoubleTapListener.onDoubleTap(mCurrentDownEvent);
                        // Give a callback with down event of the double-tap
                        handled |= mDoubleTapListener.onDoubleTapEvent(ev);
                    }
                    else
                    {
                        // This is a first tap
                        mHandler.sendEmptyMessageDelayed(TAP, DOUBLE_TAP_TIMEOUT);
                    }
                }
                mLastMotionX = x;
                mLastMotionY = y;
                if (mCurrentDownEvent != null)
                {
                    mCurrentDownEvent.recycle();
                }
                mCurrentDownEvent        = android.view.MotionEvent.obtain(ev);
                mAlwaysInTapRegion       = true;
                mAlwaysInBiggerTapRegion = true;
                mStillDown   = true;
                mInLongPress = false;
                if (mIsLongpressEnabled)
                {
                    mHandler.removeMessages(LONG_PRESS);
                    mHandler.sendEmptyMessageAtTime(LONG_PRESS, mCurrentDownEvent.getDownTime() + TAP_TIMEOUT
                                                    + LONGPRESS_TIMEOUT);
                }
                mHandler.sendEmptyMessageAtTime(SHOW_PRESS, mCurrentDownEvent.getDownTime() + TAP_TIMEOUT
                                                );
                handled |= mListener.onDown(ev);
                break;
            }

            case android.view.MotionEvent.ACTION_MOVE:
            {
                if (mInLongPress || (mIgnoreMultitouch && ev.getPointerCount() > 1))
                {
                    break;
                }
                float scrollX = mLastMotionX - x;
                float scrollY = mLastMotionY - y;
                if (mIsDoubleTapping)
                {
                    // Give the move events of the double-tap
                    handled |= mDoubleTapListener.onDoubleTapEvent(ev);
                }
                else
                {
                    if (mAlwaysInTapRegion)
                    {
                        int deltaX   = (int)(x - mCurrentDownEvent.getX());
                        int deltaY   = (int)(y - mCurrentDownEvent.getY());
                        int distance = (deltaX * deltaX) + (deltaY * deltaY);
                        if (distance > mTouchSlopSquare)
                        {
                            handled            = mListener.onScroll(mCurrentDownEvent, ev, scrollX, scrollY);
                            mLastMotionX       = x;
                            mLastMotionY       = y;
                            mAlwaysInTapRegion = false;
                            mHandler.removeMessages(TAP);
                            mHandler.removeMessages(SHOW_PRESS);
                            mHandler.removeMessages(LONG_PRESS);
                        }
                        if (distance > mBiggerTouchSlopSquare)
                        {
                            mAlwaysInBiggerTapRegion = false;
                        }
                    }
                    else
                    {
                        if ((System.Math.Abs(scrollX) >= 1) || (System.Math.Abs(scrollY) >= 1))
                        {
                            handled      = mListener.onScroll(mCurrentDownEvent, ev, scrollX, scrollY);
                            mLastMotionX = x;
                            mLastMotionY = y;
                        }
                    }
                }
                break;
            }

            case android.view.MotionEvent.ACTION_UP:
            {
                mStillDown = false;
                android.view.MotionEvent currentUpEvent = android.view.MotionEvent.obtain(ev);
                if (mIsDoubleTapping)
                {
                    // Finally, give the up event of the double-tap
                    handled |= mDoubleTapListener.onDoubleTapEvent(ev);
                }
                else
                {
                    if (mInLongPress)
                    {
                        mHandler.removeMessages(TAP);
                        mInLongPress = false;
                    }
                    else
                    {
                        if (mAlwaysInTapRegion)
                        {
                            handled = mListener.onSingleTapUp(ev);
                        }
                        else
                        {
                            // A fling must travel the minimum tap distance
                            android.view.VelocityTracker velocityTracker = mVelocityTracker;
                            velocityTracker.computeCurrentVelocity(1000, mMaximumFlingVelocity);
                            float velocityY = velocityTracker.getYVelocity();
                            float velocityX = velocityTracker.getXVelocity();
                            if ((System.Math.Abs(velocityY) > mMinimumFlingVelocity) || (System.Math.Abs(velocityX
                                                                                                         ) > mMinimumFlingVelocity))
                            {
                                handled = mListener.onFling(mCurrentDownEvent, ev, velocityX, velocityY);
                            }
                        }
                    }
                }
                if (mPreviousUpEvent != null)
                {
                    mPreviousUpEvent.recycle();
                }
                // Hold the event we obtained above - listeners may have changed the original.
                mPreviousUpEvent = currentUpEvent;
                mVelocityTracker.recycle();
                mVelocityTracker = null;
                mIsDoubleTapping = false;
                mHandler.removeMessages(SHOW_PRESS);
                mHandler.removeMessages(LONG_PRESS);
                break;
            }

            case android.view.MotionEvent.ACTION_CANCEL:
            {
                cancel();
                break;
            }
            }
            if (!handled && mInputEventConsistencyVerifier != null)
            {
                mInputEventConsistencyVerifier.onUnhandledEvent(ev, 0);
            }
            return(handled);
        }
        public virtual bool onTouchEvent(android.view.MotionEvent @event)
        {
            if (mInputEventConsistencyVerifier != null)
            {
                mInputEventConsistencyVerifier.onTouchEvent(@event, 0);
            }
            int action = @event.getActionMasked();

            if (action == android.view.MotionEvent.ACTION_DOWN)
            {
                reset();
            }
            // Start fresh
            bool handled = true;

            if (mInvalidGesture)
            {
                handled = false;
            }
            else
            {
                if (!mGestureInProgress)
                {
                    switch (action)
                    {
                    case android.view.MotionEvent.ACTION_DOWN:
                    {
                        mActiveId0         = @event.getPointerId(0);
                        mActive0MostRecent = true;
                        break;
                    }

                    case android.view.MotionEvent.ACTION_UP:
                    {
                        reset();
                        break;
                    }

                    case android.view.MotionEvent.ACTION_POINTER_DOWN:
                    {
                        // We have a new multi-finger gesture
                        // as orientation can change, query the metrics in touch down
                        android.util.DisplayMetrics metrics = mContext.getResources().getDisplayMetrics();
                        mRightSlopEdge  = metrics.widthPixels - mEdgeSlop;
                        mBottomSlopEdge = metrics.heightPixels - mEdgeSlop;
                        if (mPrevEvent != null)
                        {
                            mPrevEvent.recycle();
                        }
                        mPrevEvent = android.view.MotionEvent.obtain(@event);
                        mTimeDelta = 0;
                        int index1 = @event.getActionIndex();
                        int index0 = @event.findPointerIndex(mActiveId0);
                        mActiveId1 = @event.getPointerId(index1);
                        if (index0 < 0 || index0 == index1)
                        {
                            // Probably someone sending us a broken event stream.
                            index0     = findNewActiveIndex(@event, index0 == index1 ? -1 : mActiveId1, index0);
                            mActiveId0 = @event.getPointerId(index0);
                        }
                        mActive0MostRecent = false;
                        setContext(@event);
                        // Check if we have a sloppy gesture. If so, delay
                        // the beginning of the gesture until we're sure that's
                        // what the user wanted. Sloppy gestures can happen if the
                        // edge of the user's hand is touching the screen, for example.
                        float edgeSlop = mEdgeSlop;
                        float rightSlop = mRightSlopEdge;
                        float bottomSlop = mBottomSlopEdge;
                        float x0 = getRawX(@event, index0);
                        float y0 = getRawY(@event, index0);
                        float x1 = getRawX(@event, index1);
                        float y1 = getRawY(@event, index1);
                        bool  p0sloppy = x0 <edgeSlop || y0 <edgeSlop || x0> rightSlop || y0> bottomSlop;
                        bool  p1sloppy = x1 <edgeSlop || y1 <edgeSlop || x1> rightSlop || y1> bottomSlop;
                        if (p0sloppy && p1sloppy)
                        {
                            mFocusX        = -1;
                            mFocusY        = -1;
                            mSloppyGesture = true;
                        }
                        else
                        {
                            if (p0sloppy)
                            {
                                mFocusX        = @event.getX(index1);
                                mFocusY        = @event.getY(index1);
                                mSloppyGesture = true;
                            }
                            else
                            {
                                if (p1sloppy)
                                {
                                    mFocusX        = @event.getX(index0);
                                    mFocusY        = @event.getY(index0);
                                    mSloppyGesture = true;
                                }
                                else
                                {
                                    mSloppyGesture     = false;
                                    mGestureInProgress = mListener.onScaleBegin(this);
                                }
                            }
                        }
                        break;
                    }

                    case android.view.MotionEvent.ACTION_MOVE:
                    {
                        if (mSloppyGesture)
                        {
                            // Initiate sloppy gestures if we've moved outside of the slop area.
                            float edgeSlop = mEdgeSlop;
                            float rightSlop = mRightSlopEdge;
                            float bottomSlop = mBottomSlopEdge;
                            int   index0 = @event.findPointerIndex(mActiveId0);
                            int   index1 = @event.findPointerIndex(mActiveId1);
                            float x0 = getRawX(@event, index0);
                            float y0 = getRawY(@event, index0);
                            float x1 = getRawX(@event, index1);
                            float y1 = getRawY(@event, index1);
                            bool  p0sloppy = x0 <edgeSlop || y0 <edgeSlop || x0> rightSlop || y0> bottomSlop;
                            bool  p1sloppy = x1 <edgeSlop || y1 <edgeSlop || x1> rightSlop || y1> bottomSlop;
                            if (p0sloppy)
                            {
                                // Do we have a different pointer that isn't sloppy?
                                int index = findNewActiveIndex(@event, mActiveId1, index0);
                                if (index >= 0)
                                {
                                    index0     = index;
                                    mActiveId0 = @event.getPointerId(index);
                                    x0         = getRawX(@event, index);
                                    y0         = getRawY(@event, index);
                                    p0sloppy   = false;
                                }
                            }
                            if (p1sloppy)
                            {
                                // Do we have a different pointer that isn't sloppy?
                                int index = findNewActiveIndex(@event, mActiveId0, index1);
                                if (index >= 0)
                                {
                                    index1     = index;
                                    mActiveId1 = @event.getPointerId(index);
                                    x1         = getRawX(@event, index);
                                    y1         = getRawY(@event, index);
                                    p1sloppy   = false;
                                }
                            }
                            if (p0sloppy && p1sloppy)
                            {
                                mFocusX = -1;
                                mFocusY = -1;
                            }
                            else
                            {
                                if (p0sloppy)
                                {
                                    mFocusX = @event.getX(index1);
                                    mFocusY = @event.getY(index1);
                                }
                                else
                                {
                                    if (p1sloppy)
                                    {
                                        mFocusX = @event.getX(index0);
                                        mFocusY = @event.getY(index0);
                                    }
                                    else
                                    {
                                        mSloppyGesture     = false;
                                        mGestureInProgress = mListener.onScaleBegin(this);
                                    }
                                }
                            }
                        }
                        break;
                    }

                    case android.view.MotionEvent.ACTION_POINTER_UP:
                    {
                        if (mSloppyGesture)
                        {
                            int pointerCount = @event.getPointerCount();
                            int actionIndex  = @event.getActionIndex();
                            int actionId     = @event.getPointerId(actionIndex);
                            if (pointerCount > 2)
                            {
                                if (actionId == mActiveId0)
                                {
                                    int newIndex = findNewActiveIndex(@event, mActiveId1, actionIndex);
                                    if (newIndex >= 0)
                                    {
                                        mActiveId0 = @event.getPointerId(newIndex);
                                    }
                                }
                                else
                                {
                                    if (actionId == mActiveId1)
                                    {
                                        int newIndex = findNewActiveIndex(@event, mActiveId0, actionIndex);
                                        if (newIndex >= 0)
                                        {
                                            mActiveId1 = @event.getPointerId(newIndex);
                                        }
                                    }
                                }
                            }
                            else
                            {
                                // Set focus point to the remaining finger
                                int index = @event.findPointerIndex(actionId == mActiveId0 ? mActiveId1 : mActiveId0
                                                                    );
                                if (index < 0)
                                {
                                    mInvalidGesture = true;
                                    android.util.Log.e(TAG, "Invalid MotionEvent stream detected.", new System.Exception
                                                           ());
                                    if (mGestureInProgress)
                                    {
                                        mListener.onScaleEnd(this);
                                    }
                                    return(false);
                                }
                                mActiveId0         = @event.getPointerId(index);
                                mActive0MostRecent = true;
                                mActiveId1         = -1;
                                mFocusX            = @event.getX(index);
                                mFocusY            = @event.getY(index);
                            }
                        }
                        break;
                    }
                    }
                }
                else
                {
                    switch (action)
                    {
                    case android.view.MotionEvent.ACTION_POINTER_DOWN:
                    {
                        // Transform gesture in progress - attempt to handle it
                        // End the old gesture and begin a new one with the most recent two fingers.
                        mListener.onScaleEnd(this);
                        int oldActive0 = mActiveId0;
                        int oldActive1 = mActiveId1;
                        reset();
                        mPrevEvent         = android.view.MotionEvent.obtain(@event);
                        mActiveId0         = mActive0MostRecent ? oldActive0 : oldActive1;
                        mActiveId1         = @event.getPointerId(@event.getActionIndex());
                        mActive0MostRecent = false;
                        int index0 = @event.findPointerIndex(mActiveId0);
                        if (index0 < 0 || mActiveId0 == mActiveId1)
                        {
                            // Probably someone sending us a broken event stream.
                            android.util.Log.e(TAG, "Got " + android.view.MotionEvent.actionToString(action)
                                               + " with bad state while a gesture was in progress. " + "Did you forget to pass an event to "
                                               + "ScaleGestureDetector#onTouchEvent?");
                            index0 = findNewActiveIndex(@event, mActiveId0 == mActiveId1 ? -1 : mActiveId1, index0
                                                        );
                            mActiveId0 = @event.getPointerId(index0);
                        }
                        setContext(@event);
                        mGestureInProgress = mListener.onScaleBegin(this);
                        break;
                    }

                    case android.view.MotionEvent.ACTION_POINTER_UP:
                    {
                        int  pointerCount = @event.getPointerCount();
                        int  actionIndex  = @event.getActionIndex();
                        int  actionId     = @event.getPointerId(actionIndex);
                        bool gestureEnded = false;
                        if (pointerCount > 2)
                        {
                            if (actionId == mActiveId0)
                            {
                                int newIndex = findNewActiveIndex(@event, mActiveId1, actionIndex);
                                if (newIndex >= 0)
                                {
                                    mListener.onScaleEnd(this);
                                    mActiveId0         = @event.getPointerId(newIndex);
                                    mActive0MostRecent = true;
                                    mPrevEvent         = android.view.MotionEvent.obtain(@event);
                                    setContext(@event);
                                    mGestureInProgress = mListener.onScaleBegin(this);
                                }
                                else
                                {
                                    gestureEnded = true;
                                }
                            }
                            else
                            {
                                if (actionId == mActiveId1)
                                {
                                    int newIndex = findNewActiveIndex(@event, mActiveId0, actionIndex);
                                    if (newIndex >= 0)
                                    {
                                        mListener.onScaleEnd(this);
                                        mActiveId1         = @event.getPointerId(newIndex);
                                        mActive0MostRecent = false;
                                        mPrevEvent         = android.view.MotionEvent.obtain(@event);
                                        setContext(@event);
                                        mGestureInProgress = mListener.onScaleBegin(this);
                                    }
                                    else
                                    {
                                        gestureEnded = true;
                                    }
                                }
                            }
                            mPrevEvent.recycle();
                            mPrevEvent = android.view.MotionEvent.obtain(@event);
                            setContext(@event);
                        }
                        else
                        {
                            gestureEnded = true;
                        }
                        if (gestureEnded)
                        {
                            // Gesture ended
                            setContext(@event);
                            // Set focus point to the remaining finger
                            int activeId = actionId == mActiveId0 ? mActiveId1 : mActiveId0;
                            int index    = @event.findPointerIndex(activeId);
                            mFocusX = @event.getX(index);
                            mFocusY = @event.getY(index);
                            mListener.onScaleEnd(this);
                            reset();
                            mActiveId0         = activeId;
                            mActive0MostRecent = true;
                        }
                        break;
                    }

                    case android.view.MotionEvent.ACTION_CANCEL:
                    {
                        mListener.onScaleEnd(this);
                        reset();
                        break;
                    }

                    case android.view.MotionEvent.ACTION_UP:
                    {
                        reset();
                        break;
                    }

                    case android.view.MotionEvent.ACTION_MOVE:
                    {
                        setContext(@event);
                        // Only accept the event if our relative pressure is within
                        // a certain limit - this can help filter shaky data as a
                        // finger is lifted.
                        if (mCurrPressure / mPrevPressure > PRESSURE_THRESHOLD)
                        {
                            bool updatePrevious = mListener.onScale(this);
                            if (updatePrevious)
                            {
                                mPrevEvent.recycle();
                                mPrevEvent = android.view.MotionEvent.obtain(@event);
                            }
                        }
                        break;
                    }
                    }
                }
            }
            if (!handled && mInputEventConsistencyVerifier != null)
            {
                mInputEventConsistencyVerifier.onUnhandledEvent(@event, 0);
            }
            return(handled);
        }