Examples with VelocityTracker android.view.VelocityTracker used on opensource projects

Example 51 with VelocityTracker

use of android.view.VelocityTracker in project android_frameworks_base by ParanoidAndroid.

the class NumberPicker method onTouchEvent.

@Override
public boolean onTouchEvent(MotionEvent event) {
    if (!isEnabled() || !mHasSelectorWheel) {
        return false;
    }
    if (mVelocityTracker == null) {
        mVelocityTracker = VelocityTracker.obtain();
    }
    mVelocityTracker.addMovement(event);
    int action = event.getActionMasked();
    switch(action) {
        case MotionEvent.ACTION_MOVE:
            {
                if (mIngonreMoveEvents) {
                    break;
                }
                float currentMoveY = event.getY();
                if (mScrollState != OnScrollListener.SCROLL_STATE_TOUCH_SCROLL) {
                    int deltaDownY = (int) Math.abs(currentMoveY - mLastDownEventY);
                    if (deltaDownY > mTouchSlop) {
                        removeAllCallbacks();
                        onScrollStateChange(OnScrollListener.SCROLL_STATE_TOUCH_SCROLL);
                    }
                } else {
                    int deltaMoveY = (int) ((currentMoveY - mLastDownOrMoveEventY));
                    scrollBy(0, deltaMoveY);
                    invalidate();
                }
                mLastDownOrMoveEventY = currentMoveY;
            }
            break;
        case MotionEvent.ACTION_UP:
            {
                removeBeginSoftInputCommand();
                removeChangeCurrentByOneFromLongPress();
                mPressedStateHelper.cancel();
                VelocityTracker velocityTracker = mVelocityTracker;
                velocityTracker.computeCurrentVelocity(1000, mMaximumFlingVelocity);
                int initialVelocity = (int) velocityTracker.getYVelocity();
                if (Math.abs(initialVelocity) > mMinimumFlingVelocity) {
                    fling(initialVelocity);
                    onScrollStateChange(OnScrollListener.SCROLL_STATE_FLING);
                } else {
                    int eventY = (int) event.getY();
                    int deltaMoveY = (int) Math.abs(eventY - mLastDownEventY);
                    long deltaTime = event.getEventTime() - mLastDownEventTime;
                    if (deltaMoveY <= mTouchSlop && deltaTime < ViewConfiguration.getTapTimeout()) {
                        if (mShowSoftInputOnTap) {
                            mShowSoftInputOnTap = false;
                            showSoftInput();
                        } else {
                            int selectorIndexOffset = (eventY / mSelectorElementHeight) - SELECTOR_MIDDLE_ITEM_INDEX;
                            if (selectorIndexOffset > 0) {
                                changeValueByOne(true);
                                mPressedStateHelper.buttonTapped(PressedStateHelper.BUTTON_INCREMENT);
                            } else if (selectorIndexOffset < 0) {
                                changeValueByOne(false);
                                mPressedStateHelper.buttonTapped(PressedStateHelper.BUTTON_DECREMENT);
                            }
                        }
                    } else {
                        ensureScrollWheelAdjusted();
                    }
                    onScrollStateChange(OnScrollListener.SCROLL_STATE_IDLE);
                }
                mVelocityTracker.recycle();
                mVelocityTracker = null;
            }
            break;
    }
    return true;
}

Example 52 with VelocityTracker

use of android.view.VelocityTracker in project android_frameworks_base by ParanoidAndroid.

the class RotarySelector method onTouchEvent.

/**
     * Handle touch screen events.
     *
     * @param event The motion event.
     * @return True if the event was handled, false otherwise.
     */
@Override
public boolean onTouchEvent(MotionEvent event) {
    if (mAnimating) {
        return true;
    }
    if (mVelocityTracker == null) {
        mVelocityTracker = VelocityTracker.obtain();
    }
    mVelocityTracker.addMovement(event);
    final int height = getHeight();
    final int eventX = isHoriz() ? (int) event.getX() : height - ((int) event.getY());
    final int hitWindow = mDimpleWidth;
    final int action = event.getAction();
    switch(action) {
        case MotionEvent.ACTION_DOWN:
            if (DBG)
                log("touch-down");
            mTriggered = false;
            if (mGrabbedState != NOTHING_GRABBED) {
                reset();
                invalidate();
            }
            if (eventX < mLeftHandleX + hitWindow) {
                mRotaryOffsetX = eventX - mLeftHandleX;
                setGrabbedState(LEFT_HANDLE_GRABBED);
                invalidate();
                vibrate(VIBRATE_SHORT);
            } else if (eventX > mRightHandleX - hitWindow) {
                mRotaryOffsetX = eventX - mRightHandleX;
                setGrabbedState(RIGHT_HANDLE_GRABBED);
                invalidate();
                vibrate(VIBRATE_SHORT);
            }
            break;
        case MotionEvent.ACTION_MOVE:
            if (DBG)
                log("touch-move");
            if (mGrabbedState == LEFT_HANDLE_GRABBED) {
                mRotaryOffsetX = eventX - mLeftHandleX;
                invalidate();
                final int rightThresh = isHoriz() ? getRight() : height;
                if (eventX >= rightThresh - mEdgeTriggerThresh && !mTriggered) {
                    mTriggered = true;
                    dispatchTriggerEvent(OnDialTriggerListener.LEFT_HANDLE);
                    final VelocityTracker velocityTracker = mVelocityTracker;
                    velocityTracker.computeCurrentVelocity(1000, mMaximumVelocity);
                    final int rawVelocity = isHoriz() ? (int) velocityTracker.getXVelocity() : -(int) velocityTracker.getYVelocity();
                    final int velocity = Math.max(mMinimumVelocity, rawVelocity);
                    mDimplesOfFling = Math.max(8, Math.abs(velocity / mDimpleSpacing));
                    startAnimationWithVelocity(eventX - mLeftHandleX, mDimplesOfFling * mDimpleSpacing, velocity);
                }
            } else if (mGrabbedState == RIGHT_HANDLE_GRABBED) {
                mRotaryOffsetX = eventX - mRightHandleX;
                invalidate();
                if (eventX <= mEdgeTriggerThresh && !mTriggered) {
                    mTriggered = true;
                    dispatchTriggerEvent(OnDialTriggerListener.RIGHT_HANDLE);
                    final VelocityTracker velocityTracker = mVelocityTracker;
                    velocityTracker.computeCurrentVelocity(1000, mMaximumVelocity);
                    final int rawVelocity = isHoriz() ? (int) velocityTracker.getXVelocity() : -(int) velocityTracker.getYVelocity();
                    final int velocity = Math.min(-mMinimumVelocity, rawVelocity);
                    mDimplesOfFling = Math.max(8, Math.abs(velocity / mDimpleSpacing));
                    startAnimationWithVelocity(eventX - mRightHandleX, -(mDimplesOfFling * mDimpleSpacing), velocity);
                }
            }
            break;
        case MotionEvent.ACTION_UP:
            if (DBG)
                log("touch-up");
            // handle animating back to start if they didn't trigger
            if (mGrabbedState == LEFT_HANDLE_GRABBED && Math.abs(eventX - mLeftHandleX) > 5) {
                // set up "snap back" animation
                startAnimation(eventX - mLeftHandleX, 0, SNAP_BACK_ANIMATION_DURATION_MILLIS);
            } else if (mGrabbedState == RIGHT_HANDLE_GRABBED && Math.abs(eventX - mRightHandleX) > 5) {
                // set up "snap back" animation
                startAnimation(eventX - mRightHandleX, 0, SNAP_BACK_ANIMATION_DURATION_MILLIS);
            }
            mRotaryOffsetX = 0;
            setGrabbedState(NOTHING_GRABBED);
            invalidate();
            if (mVelocityTracker != null) {
                // wishin' we had generational GC
                mVelocityTracker.recycle();
                mVelocityTracker = null;
            }
            break;
        case MotionEvent.ACTION_CANCEL:
            if (DBG)
                log("touch-cancel");
            reset();
            invalidate();
            if (mVelocityTracker != null) {
                mVelocityTracker.recycle();
                mVelocityTracker = null;
            }
            break;
    }
    return true;
}

Example 53 with VelocityTracker

use of android.view.VelocityTracker in project android_packages_apps_DUI by DirtyUnicorns.

the class FlingGestureDetector method onTouchEvent.

/**
     * Analyzes the given motion event and if applicable triggers the
     * appropriate callbacks on the {@link OnGestureListener} supplied.
     *
     * @param ev The current motion event.
     * @return true if the {@link OnGestureListener} consumed the event,
     *              else false.
     */
public boolean onTouchEvent(MotionEvent ev) {
    if (mInputEventConsistencyVerifier != null) {
        mInputEventConsistencyVerifier.onTouchEvent(ev, 0);
    }
    final int action = ev.getAction();
    if (mVelocityTracker == null) {
        mVelocityTracker = VelocityTracker.obtain();
    }
    mVelocityTracker.addMovement(ev);
    final boolean pointerUp = (action & MotionEvent.ACTION_MASK) == MotionEvent.ACTION_POINTER_UP;
    final int skipIndex = pointerUp ? ev.getActionIndex() : -1;
    // Determine focal point
    float sumX = 0, sumY = 0;
    final int count = ev.getPointerCount();
    for (int i = 0; i < count; i++) {
        if (skipIndex == i)
            continue;
        sumX += ev.getX(i);
        sumY += ev.getY(i);
    }
    final int div = pointerUp ? count - 1 : count;
    final float focusX = sumX / div;
    final float focusY = sumY / div;
    boolean handled = false;
    switch(action & MotionEvent.ACTION_MASK) {
        case MotionEvent.ACTION_POINTER_DOWN:
            mDownFocusX = mLastFocusX = focusX;
            mDownFocusY = mLastFocusY = focusY;
            // Cancel long press and taps
            cancelTaps();
            break;
        case MotionEvent.ACTION_POINTER_UP:
            mDownFocusX = mLastFocusX = focusX;
            mDownFocusY = mLastFocusY = focusY;
            // Check the dot product of current velocities.
            // If the pointer that left was opposing another velocity vector, clear.
            mVelocityTracker.computeCurrentVelocity(1000, mMaximumFlingVelocity);
            final int upIndex = ev.getActionIndex();
            final int id1 = ev.getPointerId(upIndex);
            final float x1 = mVelocityTracker.getXVelocity(id1);
            final float y1 = mVelocityTracker.getYVelocity(id1);
            for (int i = 0; i < count; i++) {
                if (i == upIndex)
                    continue;
                final int id2 = ev.getPointerId(i);
                final float x = x1 * mVelocityTracker.getXVelocity(id2);
                final float y = y1 * mVelocityTracker.getYVelocity(id2);
                final float dot = x + y;
                if (dot < 0) {
                    mVelocityTracker.clear();
                    break;
                }
            }
            break;
        case MotionEvent.ACTION_DOWN:
            if (mDoubleTapListener != null) {
                boolean 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, getDoubleTapTimeout());
                }
            }
            mDownFocusX = mLastFocusX = focusX;
            mDownFocusY = mLastFocusY = focusY;
            if (mCurrentDownEvent != null) {
                mCurrentDownEvent.recycle();
            }
            mCurrentDownEvent = MotionEvent.obtain(ev);
            mAlwaysInTapRegion = true;
            mAlwaysInBiggerTapRegion = true;
            mStillDown = true;
            mInLongPress = false;
            mDeferConfirmSingleTap = false;
            if (mIsLongpressEnabled) {
                mHandler.removeMessages(LONG_PRESS);
                mHandler.sendEmptyMessageAtTime(LONG_PRESS, mCurrentDownEvent.getDownTime() + getTapTimeout() + getLongPressTimeout());
            }
            mHandler.sendEmptyMessageAtTime(SHOW_PRESS, mCurrentDownEvent.getDownTime() + getTapTimeout());
            handled |= mListener.onDown(ev);
            break;
        case MotionEvent.ACTION_MOVE:
            if (mInLongPress) {
                break;
            }
            final float scrollX = mLastFocusX - focusX;
            final float scrollY = mLastFocusY - focusY;
            if (mIsDoubleTapping) {
                // Give the move events of the double-tap
                handled |= mDoubleTapListener.onDoubleTapEvent(ev);
            } else if (mAlwaysInTapRegion) {
                final int deltaX = (int) (focusX - mDownFocusX);
                final int deltaY = (int) (focusY - mDownFocusY);
                int distance = (deltaX * deltaX) + (deltaY * deltaY);
                if (distance > mTouchSlopSquare) {
                    handled = mListener.onScroll(mCurrentDownEvent, ev, scrollX, scrollY);
                    mLastFocusX = focusX;
                    mLastFocusY = focusY;
                    mAlwaysInTapRegion = false;
                    mHandler.removeMessages(TAP);
                    mHandler.removeMessages(SHOW_PRESS);
                    mHandler.removeMessages(LONG_PRESS);
                }
                if (distance > mDoubleTapTouchSlopSquare) {
                    mAlwaysInBiggerTapRegion = false;
                }
            } else if ((Math.abs(scrollX) >= 1) || (Math.abs(scrollY) >= 1)) {
                handled = mListener.onScroll(mCurrentDownEvent, ev, scrollX, scrollY);
                mLastFocusX = focusX;
                mLastFocusY = focusY;
            }
            break;
        case MotionEvent.ACTION_UP:
            mStillDown = false;
            MotionEvent currentUpEvent = 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);
                if (mDeferConfirmSingleTap && mDoubleTapListener != null) {
                    mDoubleTapListener.onSingleTapConfirmed(ev);
                }
            } else {
                // A fling must travel the minimum tap distance
                final VelocityTracker velocityTracker = mVelocityTracker;
                final int pointerId = ev.getPointerId(0);
                velocityTracker.computeCurrentVelocity(1000, mMaximumFlingVelocity);
                final float velocityY = velocityTracker.getYVelocity(pointerId);
                final float velocityX = velocityTracker.getXVelocity(pointerId);
                if ((Math.abs(velocityY) > mMinimumFlingVelocity) || (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;
            if (mVelocityTracker != null) {
                // This may have been cleared when we called out to the
                // application above.
                mVelocityTracker.recycle();
                mVelocityTracker = null;
            }
            mIsDoubleTapping = false;
            mDeferConfirmSingleTap = false;
            mHandler.removeMessages(SHOW_PRESS);
            mHandler.removeMessages(LONG_PRESS);
            break;
        case MotionEvent.ACTION_CANCEL:
            cancel();
            break;
    }
    if (!handled && mInputEventConsistencyVerifier != null) {
        mInputEventConsistencyVerifier.onUnhandledEvent(ev, 0);
    }
    return handled;
}

Example 54 with VelocityTracker

use of android.view.VelocityTracker in project NewXmPluginSDK by MiEcosystem.

the class ViewFlow method onTouchEvent.

@Override
public boolean onTouchEvent(MotionEvent ev) {
    if (getChildCount() == 0)
        return false;
    if (mVelocityTracker == null) {
        mVelocityTracker = VelocityTracker.obtain();
    }
    mVelocityTracker.addMovement(ev);
    //		Log.e("ViewFlow", ev.toString());
    final int action = ev.getAction();
    final float x = ev.getX();
    mHandler.removeMessages(CANCLE_MSG);
    switch(action) {
        case MotionEvent.ACTION_DOWN:
            /*
			 * If being flinged and user touches, stop the fling. isFinished
			 * will be false if being flinged.
			 */
            if (!mScroller.isFinished()) {
                mScroller.abortAnimation();
            }
            // Remember where the motion event started
            mLastMotionX = x;
            mTouchState = mScroller.isFinished() ? TOUCH_STATE_REST : TOUCH_STATE_SCROLLING;
            break;
        case MotionEvent.ACTION_MOVE:
            final int deltaX = (int) (mLastMotionX - x);
            boolean xMoved = Math.abs(deltaX) > mTouchSlop;
            if (xMoved) {
                // Scroll if the user moved far enough along the X axis
                mTouchState = TOUCH_STATE_SCROLLING;
                if (mViewInitializeListener != null)
                    initializeView(deltaX);
            }
            if (mTouchState == TOUCH_STATE_SCROLLING) {
                // Scroll to follow the motion event
                mLastMotionX = x;
                final int scrollX = getScrollX();
                if (deltaX < 0) {
                    if (scrollX > 0) {
                        scrollBy(Math.max(-scrollX, deltaX), 0);
                    }
                } else if (deltaX > 0) {
                    final int availableToScroll = getChildAt(getChildCount() - 1).getRight() - getPaddingRight() - getHorizontalFadingEdgeLength() - scrollX - getChildWidth();
                    if (availableToScroll > 0) {
                        scrollBy(Math.min(availableToScroll, deltaX), 0);
                    }
                }
                mHandler.sendEmptyMessageDelayed(CANCLE_MSG, 200);
                return true;
            }
            break;
        case MotionEvent.ACTION_UP:
            if (mTouchState == TOUCH_STATE_SCROLLING) {
                final VelocityTracker velocityTracker = mVelocityTracker;
                velocityTracker.computeCurrentVelocity(1000, mMaximumVelocity);
                int velocityX = (int) velocityTracker.getXVelocity();
                if (velocityX > SNAP_VELOCITY && mCurrentScreen > 0) {
                    // Fling hard enough to move left
                    snapToScreen(mCurrentScreen - 1);
                } else if (velocityX < -SNAP_VELOCITY && mCurrentScreen < getChildCount() - 1) {
                    // Fling hard enough to move right
                    snapToScreen(mCurrentScreen + 1);
                } else {
                    snapToDestination();
                }
                if (mVelocityTracker != null) {
                    mVelocityTracker.recycle();
                    mVelocityTracker = null;
                }
            } else {
                if (mIndicator != null)
                    mIndicator.onItemClick(mCurrentScreen);
                snapToDestination();
            }
            mTouchState = TOUCH_STATE_REST;
            break;
        case MotionEvent.ACTION_CANCEL:
            snapToDestination();
            mTouchState = TOUCH_STATE_REST;
    }
    return true;
}

Example 55 with VelocityTracker

use of android.view.VelocityTracker in project ABPlayer by winkstu.

the class LeftSliderLayout method onTouchEvent.

@Override
public boolean onTouchEvent(MotionEvent event) {
    int nCurScrollX = getScrollX();
    // check touch point is in the rectangle of Main Child
    if (mMainChild != null && mTouchState != TOUCH_STATE_SCROLLING && mIsTouchEventDone) {
        Rect rect = new Rect();
        mMainChild.getHitRect(rect);
        if (!rect.contains((int) event.getX() + nCurScrollX, (int) event.getY())) {
            return false;
        }
    }
    if (mVelocityTracker == null) {
        mVelocityTracker = VelocityTracker.obtain();
    }
    mVelocityTracker.addMovement(event);
    final int action = event.getAction();
    final float x = event.getX();
    switch(action) {
        case MotionEvent.ACTION_DOWN:
            {
                if (!mScroller.isFinished()) {
                    mScroller.abortAnimation();
                }
                mIsTouchEventDone = false;
                mLastMotionX = x;
                break;
            }
        case MotionEvent.ACTION_MOVE:
            {
                // check slider is allowed to slide.
                if (!mEnableSlide) {
                    break;
                }
                // compute the x-axis offset from last point to current point
                int deltaX = (int) (mLastMotionX - x);
                if (nCurScrollX + deltaX < getMinScrollX()) {
                    deltaX = getMinScrollX() - nCurScrollX;
                    mLastMotionX = mLastMotionX - deltaX;
                } else if (nCurScrollX + deltaX > getMaxScrollX()) {
                    deltaX = getMaxScrollX() - nCurScrollX;
                    mLastMotionX = mLastMotionX - deltaX;
                } else {
                    mLastMotionX = x;
                }
                // Move view to the current point
                if (deltaX != 0) {
                    scrollBy(deltaX, 0);
                }
                // Save the scrolled position 
                mSaveScrollX = getScrollX();
                break;
            }
        case MotionEvent.ACTION_CANCEL:
        case MotionEvent.ACTION_UP:
            {
                // check slider is allowed to slide.
                if (!mEnableSlide) {
                    break;
                }
                final VelocityTracker velocityTracker = mVelocityTracker;
                velocityTracker.computeCurrentVelocity(mVelocityUnits);
                // Set open or close state, when get ACTION_UP or ACTION_CANCEL event.
                if (nCurScrollX < 0) {
                    int velocityX = (int) velocityTracker.getXVelocity();
                    if (velocityX > mMinorVelocity) {
                        scrollByWithAnim(getMinScrollX() - nCurScrollX);
                        setState(true);
                    } else if (velocityX < -mMinorVelocity) {
                        scrollByWithAnim(-nCurScrollX);
                        setState(false);
                    } else {
                        if (nCurScrollX >= getMinScrollX() / 2) {
                            scrollByWithAnim(-nCurScrollX);
                            setState(false);
                        } else {
                            scrollByWithAnim(getMinScrollX() - nCurScrollX);
                            setState(true);
                        }
                    }
                } else {
                    if (nCurScrollX > 0) {
                        scrollByWithAnim(-nCurScrollX);
                    }
                    setState(false);
                }
                if (mVelocityTracker != null) {
                    mVelocityTracker.recycle();
                    mVelocityTracker = null;
                }
                mTouchState = TOUCH_STATE_REST;
                mIsTouchEventDone = true;
                break;
            }
    }
    return true;
}