{
     velocitytracker = mVelocityTracker;
     k = MotionEventCompat.getPointerId(motionevent, 0);
     velocitytracker.computeCurrentVelocity(1000, mMaximumFlingVelocity);
     f = VelocityTrackerCompat.getYVelocity(velocitytracker, k);
     f1 = VelocityTrackerCompat.getXVelocity(velocitytracker, k);
     if (Math.abs(f) > (float)mMinimumFlingVelocity || Math.abs(f1) > (float)mMinimumFlingVelocity)
     {
         flag3 = mListener.mListener(mCurrentDownEvent, motionevent, f1, f);
     } else
     {
         flag3 = false;
     }
 }
コード例 #2
0
ファイル: CustomViewAbove.java プロジェクト: tobberguo/Riding
  @Override
  public boolean onTouchEvent(MotionEvent ev) {

    if (!mEnabled) return false;

    //		if (!mIsBeingDragged && !thisTouchAllowed(ev))
    //			return false;

    if (!mIsBeingDragged && !mQuickReturn) return false;

    final int action = ev.getAction();

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

    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
        mLastMotionX = mInitialMotionX = ev.getX();
        mActivePointerId = MotionEventCompat.getPointerId(ev, 0);
        break;
      case MotionEvent.ACTION_MOVE:
        if (!mIsBeingDragged) {
          if (mActivePointerId == INVALID_POINTER) break;
          final int pointerIndex = getPointerIndex(ev, mActivePointerId);
          final float x = MotionEventCompat.getX(ev, pointerIndex);
          final float dx = x - mLastMotionX;
          final float xDiff = Math.abs(dx);
          final float y = MotionEventCompat.getY(ev, pointerIndex);
          final float yDiff = Math.abs(y - mLastMotionY);
          if (DEBUG)
            Log.v(
                TAG,
                "onTouch moved to:("
                    + x
                    + ", "
                    + y
                    + "), diff:("
                    + xDiff
                    + ", "
                    + yDiff
                    + ")\nmIsBeingDragged:"
                    + mIsBeingDragged
                    + ", mLastMotionX:"
                    + mLastMotionX);
          if ((xDiff > mTouchSlop || (mQuickReturn && xDiff > mTouchSlop / 4))
              && xDiff > yDiff
              && thisSlideAllowed(dx)) {
            if (DEBUG) Log.v(TAG, "Starting drag! from onTouch");
            startDrag();
            mLastMotionX = x;
            setScrollingCacheEnabled(true);
          } else {
            if (DEBUG) Log.v(TAG, "onTouch returning false");
            return false;
          }
        }
        if (mIsBeingDragged) {
          // Scroll to follow the motion event
          final int activePointerIndex = getPointerIndex(ev, mActivePointerId);
          if (mActivePointerId == INVALID_POINTER) {
            break;
          }
          final float x = MotionEventCompat.getX(ev, activePointerIndex);
          final float deltaX = mLastMotionX - x;
          mLastMotionX = x;
          float oldScrollX = getScrollX();
          float scrollX = oldScrollX + deltaX;
          final float leftBound = getLeftBound();
          final float rightBound = getRightBound();
          if (scrollX < leftBound) {
            scrollX = leftBound;
          } else if (scrollX > rightBound) {
            scrollX = rightBound;
          }
          // Don't lose the rounded component
          mLastMotionX += scrollX - (int) scrollX;
          scrollTo((int) scrollX, getScrollY());
          pageScrolled((int) scrollX);
        }
        break;
      case MotionEvent.ACTION_UP:
        if (mIsBeingDragged) {
          final VelocityTracker velocityTracker = mVelocityTracker;
          velocityTracker.computeCurrentVelocity(1000, mMaximumVelocity);
          int initialVelocity =
              (int) VelocityTrackerCompat.getXVelocity(velocityTracker, mActivePointerId);
          final int scrollX = getScrollX();
          //				final int widthWithMargin = getWidth();
          //				final float pageOffset = (float) (scrollX % widthWithMargin) / widthWithMargin;
          // TODO test this. should get better flinging behavior
          final float pageOffset = (float) (scrollX - getDestScrollX(mCurItem)) / getBehindWidth();
          final int activePointerIndex = getPointerIndex(ev, mActivePointerId);
          if (mActivePointerId != INVALID_POINTER) {
            final float x = MotionEventCompat.getX(ev, activePointerIndex);
            final int totalDelta = (int) (x - mInitialMotionX);
            int nextPage = determineTargetPage(pageOffset, initialVelocity, totalDelta);
            setCurrentItemInternal(nextPage, true, true, initialVelocity);
          } else {
            setCurrentItemInternal(mCurItem, true, true, initialVelocity);
          }
          mActivePointerId = INVALID_POINTER;
          endDrag();
        } else if (mQuickReturn
            && mViewBehind.menuTouchInQuickReturn(mContent, mCurItem, ev.getX() + mScrollX)) {
          // close the menu
          setCurrentItem(1);
          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);
          final float x = MotionEventCompat.getX(ev, index);
          mLastMotionX = x;
          mActivePointerId = MotionEventCompat.getPointerId(ev, index);
          break;
        }
      case MotionEventCompat.ACTION_POINTER_UP:
        onSecondaryPointerUp(ev);
        int pointerIndex = this.getPointerIndex(ev, mActivePointerId);
        if (mActivePointerId == INVALID_POINTER) break;
        mLastMotionX = MotionEventCompat.getX(ev, pointerIndex);
        break;
    }
    return true;
  }
コード例 #3
0
  @Override
  public boolean onTouchEvent(MotionEvent ev) {

    if (!mEnabled) return false;

    if (!mIsBeingDragged && !thisTouchAllowed(ev)) return false;

    //		if (!mIsBeingDragged && !mQuickReturn)
    //			return false;

    final int action = ev.getAction();

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

    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
        int index = MotionEventCompat.getActionIndex(ev);
        mActivePointerId = MotionEventCompat.getPointerId(ev, index);
        mLastMotionX = mInitialMotionX = ev.getX();
        break;
      case MotionEvent.ACTION_MOVE:
        if (!mIsBeingDragged) {
          determineDrag(ev);
          if (mIsUnableToDrag) return false;
        }
        if (mIsBeingDragged) {
          // Scroll to follow the motion event
          final int activePointerIndex = getPointerIndex(ev, mActivePointerId);
          if (mActivePointerId == INVALID_POINTER) break;
          final float x = MotionEventCompat.getX(ev, activePointerIndex);
          final float deltaX = mLastMotionX - x;
          mLastMotionX = x;
          float oldScrollX = getScrollX();
          float scrollX = oldScrollX + deltaX;
          final float leftBound = getLeftBound();
          final float rightBound = getRightBound();
          if (scrollX < leftBound) {
            scrollX = leftBound;
          } else if (scrollX > rightBound) {
            scrollX = rightBound;
          }
          // Don't lose the rounded component
          mLastMotionX += scrollX - (int) scrollX;
          scrollTo((int) scrollX, getScrollY());
          pageScrolled((int) scrollX);
        }
        break;
      case MotionEvent.ACTION_UP:
        if (mIsBeingDragged) {
          final VelocityTracker velocityTracker = mVelocityTracker;
          velocityTracker.computeCurrentVelocity(1000, mMaximumVelocity);
          int initialVelocity =
              (int) VelocityTrackerCompat.getXVelocity(velocityTracker, mActivePointerId);
          final int scrollX = getScrollX();
          final float pageOffset = (float) (scrollX - getDestScrollX(mCurItem)) / getBehindWidth();
          final int activePointerIndex = getPointerIndex(ev, mActivePointerId);
          if (mActivePointerId != INVALID_POINTER) {
            final float x = MotionEventCompat.getX(ev, activePointerIndex);
            final int totalDelta = (int) (x - mInitialMotionX);
            int nextPage = determineTargetPage(pageOffset, initialVelocity, totalDelta);
            setCurrentItemInternal(nextPage, true, true, initialVelocity);
          } else {
            setCurrentItemInternal(mCurItem, true, true, initialVelocity);
          }
          mActivePointerId = INVALID_POINTER;
          endDrag();
        } else if (mQuickReturn
            && mViewBehind.menuTouchInQuickReturn(mContent, mCurItem, ev.getX() + mScrollX)) {
          // close the menu
          setCurrentItem(1);
          endDrag();
        }
        break;
      case MotionEvent.ACTION_CANCEL:
        if (mIsBeingDragged) {
          setCurrentItemInternal(mCurItem, true, true);
          mActivePointerId = INVALID_POINTER;
          endDrag();
        }
        break;
      case MotionEventCompat.ACTION_POINTER_DOWN:
        {
          final int indexx = MotionEventCompat.getActionIndex(ev);
          mLastMotionX = MotionEventCompat.getX(ev, indexx);
          mActivePointerId = MotionEventCompat.getPointerId(ev, indexx);
          break;
        }
      case MotionEventCompat.ACTION_POINTER_UP:
        onSecondaryPointerUp(ev);
        int pointerIndex = getPointerIndex(ev, mActivePointerId);
        if (mActivePointerId == INVALID_POINTER) break;
        mLastMotionX = MotionEventCompat.getX(ev, pointerIndex);
        break;
    }
    return true;
  }
コード例 #4
0
        @Override
        public boolean onTouch(final View v, MotionEvent event) {
          int index = event.getActionIndex();
          int pointerId = event.getPointerId(index);

          if (mSwipeSlop < 0) {
            mSwipeSlop = ViewConfiguration.get(getActivity()).getScaledTouchSlop();
          }

          v.onTouchEvent(event);

          switch (event.getAction()) {
            case MotionEvent.ACTION_DOWN:
              if (mItemPressed) {
                // Multi-item swipes not handled
                return false;
              }
              mItemPressed = true;
              mDownX = event.getX();
              if (mVelocityTracker == null) {
                // Retrieve a new VelocityTracker object to watch the velocity of a motion.
                mVelocityTracker = VelocityTracker.obtain();
              } else {
                // Reset the velocity tracker back to its initial state.
                mVelocityTracker.clear();
              }
              mVelocityTracker.addMovement(event);
              break;
            case MotionEvent.ACTION_CANCEL:
              v.setAlpha(1);
              v.setTranslationX(0);
              mItemPressed = false;
              mVelocityTracker.recycle();
              mVelocityTracker = null;
              break;
            case MotionEvent.ACTION_MOVE:
              {
                mVelocityTracker.addMovement(event);
                float x = event.getX() + v.getTranslationX();
                float deltaX = x - mDownX;
                float deltaXAbs = Math.abs(deltaX);
                if (!mSwiping) {
                  if (deltaXAbs > mSwipeSlop) {
                    mSwiping = true;
                    getListView().requestDisallowInterceptTouchEvent(true);
                    mBackgroundContainer.showBackground(v.getTop(), v.getHeight());
                  }
                }
                if (mSwiping) {
                  v.setTranslationX((x - mDownX));
                  v.setAlpha(1 - deltaXAbs / v.getWidth());
                }
              }
              break;
            case MotionEvent.ACTION_UP:
              {
                // User let go - figure out whether to animate the view out, or back into place
                if (mSwiping) {
                  float x = event.getX() + v.getTranslationX();
                  float deltaX = x - mDownX;
                  float deltaXAbs = Math.abs(deltaX);
                  float fractionCovered;
                  float endX;
                  float endAlpha;
                  final boolean remove;
                  mVelocityTracker.computeCurrentVelocity(1000);
                  float velocityX =
                      Math.abs(VelocityTrackerCompat.getXVelocity(mVelocityTracker, pointerId));
                  if (velocityX > 700 || deltaXAbs > v.getWidth() / 4) {
                    fractionCovered = deltaXAbs / v.getWidth();
                    endX = deltaX < 0 ? -v.getWidth() : v.getWidth();
                    endAlpha = 0;
                    remove = true;
                  } else {
                    // Not far enough - animate it back
                    fractionCovered = 1 - (deltaXAbs / v.getWidth());
                    endX = 0;
                    endAlpha = 1;
                    remove = false;
                  }
                  mVelocityTracker.clear();
                  int SWIPE_DURATION = 600;
                  long duration = (int) ((1 - fractionCovered) * SWIPE_DURATION);
                  getListView().setEnabled(false);
                  v.animate()
                      .setDuration(Math.abs(duration))
                      .alpha(endAlpha)
                      .translationX(endX)
                      .setListener(
                          new AnimatorActionListener(
                              new Runnable() {
                                @Override
                                public void run() {
                                  // Restore animated values
                                  v.setAlpha(1);
                                  v.setTranslationX(0);
                                  if (remove) {
                                    animateRemoval(getListView(), v);
                                  } else {
                                    mBackgroundContainer.hideBackground();
                                    getListView().setEnabled(true);
                                  }
                                }
                              },
                              AnimatorActionListener.ActionType.END));
                }
              }
              mItemPressed = false;
              break;
            default:
              return false;
          }
          return true;
        }
    public boolean onTouchEvent(MotionEvent motionevent)
    {
        float f;
        float f1;
        int i2;
        int j2 = motionevent.getAction();
        if (mVelocityTracker == null)
        {
            mVelocityTracker = VelocityTracker.obtain();
        }
        mVelocityTracker.addMovement(motionevent);
        boolean flag;
        int l;
        int k1;
        if ((j2 & 0xff) == 6)
        {
            flag = true;
        } else
        {
            flag = false;
        }
        if (flag)
        {
            l = MotionEventCompat.getActionIndex(motionevent);
        } else
        {
            l = -1;
        }
        i2 = MotionEventCompat.getPointerCount(motionevent);
        k1 = 0;
        f = 0.0F;
        float f2;
        for (f1 = 0.0F; k1 < i2; f1 = f2)
        {
            float f5 = f;
            f2 = f1;
            if (l != k1)
            {
                f2 = f1 + MotionEventCompat.getX(motionevent, k1);
                f5 = f + MotionEventCompat.getY(motionevent, k1);
            }
            k1++;
            f = f5;
        }

        int i;
        if (flag)
        {
            i = i2 - 1;
        } else
        {
            i = i2;
        }
        f1 /= i;
        f /= i;
        j2 & 0xff;
        JVM INSTR tableswitch 0 6: default 204
    //                   0 383
    //                   1 862
    //                   2 643
    //                   3 1136
    //                   4 204
    //                   5 213
    //                   6 239;
           goto _L1 _L2 _L3 _L4 _L5 _L1 _L6 _L7
_L1:
        return false;
_L6:
        mLastFocusX = f1;
        mDownFocusX = f1;
        mLastFocusY = f;
        mDownFocusY = f;
        cancelTaps();
        return false;
_L7:
        mLastFocusX = f1;
        mDownFocusX = f1;
        mLastFocusY = f;
        mDownFocusY = f;
        mVelocityTracker.computeCurrentVelocity(1000, mMaximumFlingVelocity);
        int i1 = MotionEventCompat.getActionIndex(motionevent);
        int j = MotionEventCompat.getPointerId(motionevent, i1);
        f = VelocityTrackerCompat.getXVelocity(mVelocityTracker, j);
        f1 = VelocityTrackerCompat.getYVelocity(mVelocityTracker, j);
        j = 0;
        while (j < i2) 
        {
            if (j != i1)
            {
                int l1 = MotionEventCompat.getPointerId(motionevent, j);
                float f3 = VelocityTrackerCompat.getXVelocity(mVelocityTracker, l1);
                if (VelocityTrackerCompat.getYVelocity(mVelocityTracker, l1) * f1 + f3 * f < 0.0F)
                {
                    mVelocityTracker.clear();
                    return false;
                }
            }
            j++;
        }
          goto _L8
コード例 #6
0
  @Override
  public boolean onTouch(MotionEvent e) {
    switch (e.getAction()) {
      case MotionEvent.ACTION_DOWN:
        if (gamestate == State.ROUNDSUMMARY
            || gamestate == State.STARTGAME
            || gamestate == State.PLAYERDIED) {
          // Game�̏�����
          randomSpeed = 1;
          gamestate = State.STARTROUND; // prep and start round
          return false; // no followup msgs
        } else if (gamestate == State.GAMEOVER) {
          act.leaveGame(); // user touched after gameover -> back to entry screen
          return false; // no followup msgs
        } else {
          synchronized (fruitsSelectable) {
            Iterator<Fruit> itf = fruitsSelectable.iterator();
            while (itf.hasNext()) {
              Fruit f = itf.next();
              if (f.hasCollision(e.getX(), e.getY()))
                if (f.seed == ketseed) {
                  // user popped ketchup
                  act.playSound(Sound.KSPLAT);
                  f.burst();
                  loseLife();
                  return false; // no followup msgs
                } else {
                  // user picked up a fruit
                  selectedFruit = f;
                }
            }
          }
          if (mVelocityTracker == null) {
            // Retrieve a new VelocityTracker object to watch the velocity of a motion.
            mVelocityTracker = VelocityTracker.obtain();
          } else {
            // Reset the velocity tracker back to its initial state.
            mVelocityTracker.clear();
          }
          // Add a user's movement to the tracker.
          mVelocityTracker.addMovement(e);
        }
        break;

      case MotionEvent.ACTION_MOVE:
        if (selectedFruit != null) {
          selectedFruit.x = e.getX();
          selectedFruit.y = e.getY();
        }
        mVelocityTracker.addMovement(e);
        break;

      case MotionEvent.ACTION_UP:
        if (selectedFruit != null) {
          Fruit f = selectedFruit;
          selectedFruit = null;

          mVelocityTracker.computeCurrentVelocity(1000);
          int pointerId = e.getPointerId(e.getActionIndex());
          float tvx = VelocityTrackerCompat.getXVelocity(mVelocityTracker, pointerId);
          float tvy = VelocityTrackerCompat.getYVelocity(mVelocityTracker, pointerId);

          if (-tvy > 10) {
            // there is upward motion at release-- user threw fruit

            // scale throw speed for display size/density
            tvx = tvx / act.densityscalefactor;
            tvy = tvy / act.densityscalefactor;

            // help ease perspective problem when we release fruit away from the horizontal center
            // of the screen
            tvx += (e.getX() - width / 2) * 3.5 * act.densityscalefactor;

            f.throwFruit(tvx, tvy);
            synchronized (fruitsFlying) {
              fruitsFlying.add(f);
              fruitsSelectable.remove(f);
            }

            // attempting to adjust sound for how hard fruit was thrown horizontally.
            // hardness == 0 --> not thrown with any force
            // hardness == 1 --> thrown as hard as possible
            // assume that 5000 represents "really fast"; z vel should sound "harder" than y-vel
            float hardness = (f.vz - f.vy / 2) / 5000; // vy: up is negative.
            if (hardness >= 1f) hardness = 1.0f;
            if (hardness < .3f) hardness = .3f;
            act.playSound(Sound.THROW, hardness * .9f, hardness * 2);
          }
        }
        mVelocityTracker.recycle();
        // seems to be a bug here on android 4.4, causing IllegalStateException - not addressing,
        // since it doesn't affect game play, and may be resolved in later versions
        break;
    }

    return true;
  }
コード例 #7
0
  @Override
  public boolean onTouchEvent(MotionEvent ev) {
    if (!mEnabled
        || !mIsDragging
            && !mLastTouchAllowed
            && !allowSlidingFromHereX(ev, mInitialX)
            && !allowSlidingFromHereY(ev, mInitialY)) {
      return false;
    }

    final int action = ev.getAction();

    if (action == MotionEvent.ACTION_UP
        || action == MotionEvent.ACTION_CANCEL
        || action == MotionEvent.ACTION_OUTSIDE) {
      mLastTouchAllowed = false;
    } else {
      mLastTouchAllowed = true;
    }

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

    switch (action & MotionEventCompat.ACTION_MASK) {
      case MotionEvent.ACTION_DOWN:
        completeScroll();

        // Remember where the motion event started
        mLastX = mInitialX = ev.getX();
        mLastY = mInitialY = ev.getY();
        mActivePointerId = MotionEventCompat.getPointerId(ev, 0);
        break;
      case MotionEvent.ACTION_MOVE:
        if (!mIsDragging) {
          final int pointerIndex = MotionEventCompat.findPointerIndex(ev, mActivePointerId);
          if (pointerIndex == -1) {
            mActivePointerId = INVALID_POINTER;
            break;
          }
          final float x = MotionEventCompat.getX(ev, pointerIndex);
          final float xDiff = Math.abs(x - mLastX);
          final float y = MotionEventCompat.getY(ev, pointerIndex);
          final float yDiff = Math.abs(y - mLastY);
          if (xDiff > mTouchSlop && xDiff > yDiff) {
            mIsDragging = true;
            mLastX = x;
            setDrawingCacheEnabled(true);
          } else if (yDiff > mTouchSlop && yDiff > xDiff) {
            mIsDragging = true;
            mLastY = y;
            setDrawingCacheEnabled(true);
          }
        }
        if (mIsDragging) {
          // Scroll to follow the motion event
          final int activePointerIndex = MotionEventCompat.findPointerIndex(ev, mActivePointerId);
          if (activePointerIndex == -1) {
            mActivePointerId = INVALID_POINTER;
            break;
          }
          final float x = MotionEventCompat.getX(ev, activePointerIndex);
          final float y = MotionEventCompat.getY(ev, activePointerIndex);
          final float deltaX = mLastX - x;
          final float deltaY = mLastY - y;
          mLastX = x;
          mLastY = y;
          final float oldScrollX = getScrollX();
          final float oldScrollY = getScrollY();
          float scrollX = oldScrollX + deltaX;
          float scrollY = oldScrollY + deltaY;

          // Log.d("Layer", String.format("Layer scrollX[%f],scrollY[%f]", scrollX, scrollY));
          final float leftBound, rightBound;
          final float bottomBound, topBound;
          switch (mScreenSide) {
            case STICK_TO_LEFT:
              topBound = bottomBound = rightBound = 0;
              leftBound = getWidth(); // How far left we can scroll
              break;
            case STICK_TO_MIDDLE:
              topBound = getHeight();
              bottomBound = -getHeight();
              leftBound = getWidth();
              rightBound = -getWidth();
              break;
            case STICK_TO_RIGHT:
              rightBound = -getWidth();
              topBound = bottomBound = leftBound = 0;
              break;
            case STICK_TO_TOP:
              topBound = getHeight();
              bottomBound = rightBound = leftBound = 0;
              break;
            case STICK_TO_BOTTOM:
              topBound = rightBound = leftBound = 0;
              bottomBound = -getHeight();
              break;
            default:
              topBound = bottomBound = rightBound = leftBound = 0;
              break;
          }
          if (scrollX > leftBound) {
            scrollX = leftBound;
          } else if (scrollX < rightBound) {
            scrollX = rightBound;
          }
          if (scrollY > topBound) {
            scrollY = topBound;
          } else if (scrollY < bottomBound) {
            scrollY = bottomBound;
          }

          // Keep the precision
          mLastX += scrollX - (int) scrollX;
          mLastY += scrollY - (int) scrollY;
          scrollTo((int) scrollX, (int) scrollY);
        }
        break;
      case MotionEvent.ACTION_UP:
        if (mIsDragging) {
          final VelocityTracker velocityTracker = mVelocityTracker;
          velocityTracker.computeCurrentVelocity(1000, mMaximumVelocity);
          final int initialVelocityX =
              (int) VelocityTrackerCompat.getXVelocity(velocityTracker, mActivePointerId);
          final int initialVelocityY =
              (int) VelocityTrackerCompat.getYVelocity(velocityTracker, mActivePointerId);
          final int scrollX = getScrollX();
          final int scrollY = getScrollY();
          final int activePointerIndex = MotionEventCompat.findPointerIndex(ev, mActivePointerId);
          final float x = MotionEventCompat.getX(ev, activePointerIndex);
          final float y = MotionEventCompat.getY(ev, activePointerIndex);
          final int totalDeltaX = (int) (x - mInitialX);
          final int totalDeltaY = (int) (y - mInitialY);

          boolean nextStateOpened =
              determineNextStateOpened(
                  mIsOpen,
                  scrollX,
                  scrollY,
                  initialVelocityX,
                  initialVelocityY,
                  totalDeltaX,
                  totalDeltaY);
          switchLayer(nextStateOpened, true, true, initialVelocityX, initialVelocityY);

          mActivePointerId = INVALID_POINTER;
          endDrag();
        } else if (mIsOpen && closeOnTapEnabled) {
          closeLayer(true);
        } else if (!mIsOpen && openOnTapEnabled) {
          openLayer(true);
        }
        break;
      case MotionEvent.ACTION_CANCEL:
        if (mIsDragging) {
          switchLayer(mIsOpen, true, true);
          mActivePointerId = INVALID_POINTER;
          endDrag();
        }
        break;
      case MotionEventCompat.ACTION_POINTER_DOWN:
        {
          final int index = MotionEventCompat.getActionIndex(ev);
          mLastX = MotionEventCompat.getX(ev, index);
          mLastY = MotionEventCompat.getY(ev, index);
          mActivePointerId = MotionEventCompat.getPointerId(ev, index);
          break;
        }
      case MotionEventCompat.ACTION_POINTER_UP:
        onSecondaryPointerUp(ev);
        mLastX =
            MotionEventCompat.getX(ev, MotionEventCompat.findPointerIndex(ev, mActivePointerId));
        mLastY =
            MotionEventCompat.getY(ev, MotionEventCompat.findPointerIndex(ev, mActivePointerId));
        break;
    }
    if (mActivePointerId == INVALID_POINTER) {
      mLastTouchAllowed = false;
    }
    return true;
  }
コード例 #8
0
ファイル: FlipView.java プロジェクト: Y-bao/Android
  @Override
  public boolean onTouchEvent(MotionEvent ev) {

    if (!mIsFlippingEnabled) {
      return false;
    }

    if (mPageCount < 1) {
      return false;
    }

    if (!mIsFlipping && !mLastTouchAllowed) {
      return false;
    }

    final int action = ev.getAction();

    if (action == MotionEvent.ACTION_UP
        || action == MotionEvent.ACTION_CANCEL
        || action == MotionEvent.ACTION_OUTSIDE) {
      mLastTouchAllowed = false;
    } else {
      mLastTouchAllowed = true;
    }

    trackVelocity(ev);

    switch (action & MotionEvent.ACTION_MASK) {
      case MotionEvent.ACTION_DOWN:

        // start flipping immediately if interrupting some sort of animation
        if (endScroll() || endPeak()) {
          mIsFlipping = true;
        }

        // Remember where the motion event started
        mLastX = ev.getX();
        mLastY = ev.getY();
        mActivePointerId = MotionEventCompat.getPointerId(ev, 0);
        break;
      case MotionEvent.ACTION_MOVE:
        if (!mIsFlipping) {
          final int pointerIndex = MotionEventCompat.findPointerIndex(ev, mActivePointerId);
          if (pointerIndex == -1) {
            mActivePointerId = INVALID_POINTER;
            break;
          }
          final float x = MotionEventCompat.getX(ev, pointerIndex);
          final float xDiff = Math.abs(x - mLastX);
          final float y = MotionEventCompat.getY(ev, pointerIndex);
          final float yDiff = Math.abs(y - mLastY);
          if ((mIsFlippingVertically && yDiff > mTouchSlop && yDiff > xDiff)
              || (!mIsFlippingVertically && xDiff > mTouchSlop && xDiff > yDiff)) {
            mIsFlipping = true;
            mLastX = x;
            mLastY = y;
          }
        }
        if (mIsFlipping) {
          // Scroll to follow the motion event
          final int activePointerIndex = MotionEventCompat.findPointerIndex(ev, mActivePointerId);
          if (activePointerIndex == -1) {
            mActivePointerId = INVALID_POINTER;
            break;
          }
          final float x = MotionEventCompat.getX(ev, activePointerIndex);
          final float deltaX = mLastX - x;
          final float y = MotionEventCompat.getY(ev, activePointerIndex);
          final float deltaY = mLastY - y;
          mLastX = x;
          mLastY = y;

          float deltaFlipDistance = 0;
          if (mIsFlippingVertically) {
            deltaFlipDistance = deltaY;
          } else {
            deltaFlipDistance = deltaX;
          }

          deltaFlipDistance /=
              ((isFlippingVertically() ? getHeight() : getWidth()) / FLIP_DISTANCE_PER_PAGE);
          setFlipDistance(mFlipDistance + deltaFlipDistance);

          final int minFlipDistance = 0;
          final int maxFlipDistance = (mPageCount - 1) * FLIP_DISTANCE_PER_PAGE;
          final boolean isOverFlipping =
              mFlipDistance < minFlipDistance || mFlipDistance > maxFlipDistance;
          if (isOverFlipping) {
            mIsOverFlipping = true;
            setFlipDistance(
                mOverFlipper.calculate(mFlipDistance, minFlipDistance, maxFlipDistance));
            if (mOnOverFlipListener != null) {
              float overFlip = mOverFlipper.getTotalOverFlip();
              mOnOverFlipListener.onOverFlip(
                  this, mOverFlipMode, overFlip < 0, Math.abs(overFlip), FLIP_DISTANCE_PER_PAGE);
            }
          } else if (mIsOverFlipping) {
            mIsOverFlipping = false;
            if (mOnOverFlipListener != null) {
              // TODO in the future should only notify flip distance 0
              // on the correct edge (previous/next)
              mOnOverFlipListener.onOverFlip(this, mOverFlipMode, false, 0, FLIP_DISTANCE_PER_PAGE);
              mOnOverFlipListener.onOverFlip(this, mOverFlipMode, true, 0, FLIP_DISTANCE_PER_PAGE);
            }
          }
        }
        break;
      case MotionEvent.ACTION_UP:
      case MotionEvent.ACTION_CANCEL:
        if (mIsFlipping) {
          final VelocityTracker velocityTracker = mVelocityTracker;
          velocityTracker.computeCurrentVelocity(1000, mMaximumVelocity);

          int velocity = 0;
          if (isFlippingVertically()) {
            velocity = (int) VelocityTrackerCompat.getYVelocity(velocityTracker, mActivePointerId);
          } else {
            velocity = (int) VelocityTrackerCompat.getXVelocity(velocityTracker, mActivePointerId);
          }
          smoothFlipTo(getNextPage(velocity));

          mActivePointerId = INVALID_POINTER;
          endFlip();

          mOverFlipper.overFlipEnded();
        }
        break;
      case MotionEventCompat.ACTION_POINTER_DOWN:
        {
          final int index = MotionEventCompat.getActionIndex(ev);
          final float x = MotionEventCompat.getX(ev, index);
          final float y = MotionEventCompat.getY(ev, index);
          mLastX = x;
          mLastY = y;
          mActivePointerId = MotionEventCompat.getPointerId(ev, index);
          break;
        }
      case MotionEventCompat.ACTION_POINTER_UP:
        onSecondaryPointerUp(ev);
        final int index = MotionEventCompat.findPointerIndex(ev, mActivePointerId);
        final float x = MotionEventCompat.getX(ev, index);
        final float y = MotionEventCompat.getY(ev, index);
        mLastX = x;
        mLastY = y;
        break;
    }
    if (mActivePointerId == INVALID_POINTER) {
      mLastTouchAllowed = false;
    }
    return true;
  }
コード例 #9
0
  @Override
  public boolean onTouchEvent(MotionEvent e) {
    /*
    if (mLayoutFrozen || mIgnoreMotionEventTillDown) {
        return false;
    }
    if (dispatchOnItemTouch(e)) {
        cancelTouch();
        return true;
    }

    if (mLayout == null) {
        return false;
    }
    */

    final boolean canScrollHorizontally = false; // mLayout.canScrollHorizontally();
    final boolean canScrollVertically = true; // mLayout.canScrollVertically();

    if (mVelocityTracker == null) {
      mVelocityTracker = VelocityTracker.obtain();
    }
    boolean eventAddedToVelocityTracker = false;

    final MotionEvent vtev = MotionEvent.obtain(e);
    final int action = MotionEventCompat.getActionMasked(e);
    final int actionIndex = MotionEventCompat.getActionIndex(e);

    if (action == MotionEvent.ACTION_DOWN) {
      mNestedOffsets[0] = mNestedOffsets[1] = 0;
    }
    vtev.offsetLocation(mNestedOffsets[0], mNestedOffsets[1]);

    switch (action) {
      case MotionEvent.ACTION_DOWN:
        {
          mScrollPointerId = MotionEventCompat.getPointerId(e, 0);
          mInitialTouchX = mLastTouchX = (int) (e.getX() + 0.5f);
          mInitialTouchY = mLastTouchY = (int) (e.getY() + 0.5f);

          int nestedScrollAxis = ViewCompat.SCROLL_AXIS_NONE;
          if (canScrollHorizontally) {
            nestedScrollAxis |= ViewCompat.SCROLL_AXIS_HORIZONTAL;
          }
          if (canScrollVertically) {
            nestedScrollAxis |= ViewCompat.SCROLL_AXIS_VERTICAL;
          }
          startNestedScroll(nestedScrollAxis);
        }
        break;

      case MotionEventCompat.ACTION_POINTER_DOWN:
        {
          mScrollPointerId = MotionEventCompat.getPointerId(e, actionIndex);
          mInitialTouchX = mLastTouchX = (int) (MotionEventCompat.getX(e, actionIndex) + 0.5f);
          mInitialTouchY = mLastTouchY = (int) (MotionEventCompat.getY(e, actionIndex) + 0.5f);
        }
        break;

      case MotionEvent.ACTION_MOVE:
        {
          final int index = MotionEventCompat.findPointerIndex(e, mScrollPointerId);
          if (index < 0) {
            Log.e(
                TAG,
                "Error processing scroll; pointer index for id "
                    + mScrollPointerId
                    + " not found. Did any MotionEvents get skipped?");
            return false;
          }

          final int x = (int) (MotionEventCompat.getX(e, index) + 0.5f);
          final int y = (int) (MotionEventCompat.getY(e, index) + 0.5f);
          int dx = mLastTouchX - x;
          int dy = mLastTouchY - y;

          if (dispatchNestedPreScroll(dx, dy, mScrollConsumed, mScrollOffset)) {
            dx -= mScrollConsumed[0];
            dy -= mScrollConsumed[1];
            vtev.offsetLocation(mScrollOffset[0], mScrollOffset[1]);
            // Updated the nested offsets
            mNestedOffsets[0] += mScrollOffset[0];
            mNestedOffsets[1] += mScrollOffset[1];
          }

          if (mScrollState != SCROLL_STATE_DRAGGING) {
            boolean startScroll = false;
            if (canScrollHorizontally && Math.abs(dx) > mTouchSlop) {
              if (dx > 0) {
                dx -= mTouchSlop;
              } else {
                dx += mTouchSlop;
              }
              startScroll = true;
            }
            if (canScrollVertically && Math.abs(dy) > mTouchSlop) {
              if (dy > 0) {
                dy -= mTouchSlop;
              } else {
                dy += mTouchSlop;
              }
              startScroll = true;
            }
            if (startScroll) {
              setScrollState(SCROLL_STATE_DRAGGING);
            }
          }

          if (mScrollState == SCROLL_STATE_DRAGGING) {
            mLastTouchX = x - mScrollOffset[0];
            mLastTouchY = y - mScrollOffset[1];

            if (scrollByInternal(
                canScrollHorizontally ? dx : 0, canScrollVertically ? dy : 0, vtev)) {
              getParent().requestDisallowInterceptTouchEvent(true);
            }
          }
        }
        break;

      case MotionEventCompat.ACTION_POINTER_UP:
        {
          onPointerUp(e);
        }
        break;

      case MotionEvent.ACTION_UP:
        {
          mVelocityTracker.addMovement(vtev);
          eventAddedToVelocityTracker = true;
          mVelocityTracker.computeCurrentVelocity(1000, mMaxFlingVelocity);
          final float xvel =
              canScrollHorizontally
                  ? -VelocityTrackerCompat.getXVelocity(mVelocityTracker, mScrollPointerId)
                  : 0;
          final float yvel =
              canScrollVertically
                  ? -VelocityTrackerCompat.getYVelocity(mVelocityTracker, mScrollPointerId)
                  : 0;
          if (!((xvel != 0 || yvel != 0) && fling((int) xvel, (int) yvel))) {
            setScrollState(SCROLL_STATE_IDLE);
          }
          resetTouch();
        }
        break;

      case MotionEvent.ACTION_CANCEL:
        {
          cancelTouch();
        }
        break;
    }

    if (!eventAddedToVelocityTracker) {
      mVelocityTracker.addMovement(vtev);
    }
    vtev.recycle();

    return true;
  }
コード例 #10
0
ファイル: NestedScrollView.java プロジェクト: eFOIA-12/eFOIA
  public boolean onTouchEvent(MotionEvent var1) {
    this.initVelocityTrackerIfNotExists();
    MotionEvent var9 = MotionEvent.obtain(var1);
    int var2 = MotionEventCompat.getActionMasked(var1);
    if (var2 == 0) {
      this.mNestedYOffset = 0;
    }

    var9.offsetLocation(0.0F, (float) this.mNestedYOffset);
    ViewParent var10;
    switch (var2) {
      case 0:
        if (this.getChildCount() == 0) {
          return false;
        }

        boolean var8;
        if (!this.mScroller.isFinished()) {
          var8 = true;
        } else {
          var8 = false;
        }

        this.mIsBeingDragged = var8;
        if (var8) {
          var10 = this.getParent();
          if (var10 != null) {
            var10.requestDisallowInterceptTouchEvent(true);
          }
        }

        if (!this.mScroller.isFinished()) {
          this.mScroller.abortAnimation();
        }

        this.mLastMotionY = (int) var1.getY();
        this.mActivePointerId = MotionEventCompat.getPointerId(var1, 0);
        this.startNestedScroll(2);
        break;
      case 1:
        if (this.mIsBeingDragged) {
          VelocityTracker var11 = this.mVelocityTracker;
          var11.computeCurrentVelocity(1000, (float) this.mMaximumVelocity);
          var2 = (int) VelocityTrackerCompat.getYVelocity(var11, this.mActivePointerId);
          if (Math.abs(var2) > this.mMinimumVelocity) {
            this.flingWithNestedDispatch(-var2);
          }

          this.mActivePointerId = -1;
          this.endDrag();
        }
        break;
      case 2:
        int var4 = MotionEventCompat.findPointerIndex(var1, this.mActivePointerId);
        if (var4 == -1) {
          Log.e(
              "NestedScrollView",
              "Invalid pointerId=" + this.mActivePointerId + " in onTouchEvent");
        } else {
          int var5 = (int) MotionEventCompat.getY(var1, var4);
          var2 = this.mLastMotionY - var5;
          int var3 = var2;
          if (this.dispatchNestedPreScroll(0, var2, this.mScrollConsumed, this.mScrollOffset)) {
            var3 = var2 - this.mScrollConsumed[1];
            var9.offsetLocation(0.0F, (float) this.mScrollOffset[1]);
            this.mNestedYOffset += this.mScrollOffset[1];
          }

          var2 = var3;
          if (!this.mIsBeingDragged) {
            var2 = var3;
            if (Math.abs(var3) > this.mTouchSlop) {
              var10 = this.getParent();
              if (var10 != null) {
                var10.requestDisallowInterceptTouchEvent(true);
              }

              this.mIsBeingDragged = true;
              if (var3 > 0) {
                var2 = var3 - this.mTouchSlop;
              } else {
                var2 = var3 + this.mTouchSlop;
              }
            }
          }

          if (this.mIsBeingDragged) {
            this.mLastMotionY = var5 - this.mScrollOffset[1];
            int var6 = this.getScrollY();
            var5 = this.getScrollRange();
            var3 = ViewCompat.getOverScrollMode(this);
            boolean var12;
            if (var3 != 0 && (var3 != 1 || var5 <= 0)) {
              var12 = false;
            } else {
              var12 = true;
            }

            if (this.overScrollByCompat(0, var2, 0, this.getScrollY(), 0, var5, 0, 0, true)
                && !this.hasNestedScrollingParent()) {
              this.mVelocityTracker.clear();
            }

            int var7 = this.getScrollY() - var6;
            if (this.dispatchNestedScroll(0, var7, 0, var2 - var7, this.mScrollOffset)) {
              this.mLastMotionY -= this.mScrollOffset[1];
              var9.offsetLocation(0.0F, (float) this.mScrollOffset[1]);
              this.mNestedYOffset += this.mScrollOffset[1];
            } else if (var12) {
              this.ensureGlows();
              var3 = var6 + var2;
              if (var3 < 0) {
                this.mEdgeGlowTop.onPull(
                    (float) var2 / (float) this.getHeight(),
                    MotionEventCompat.getX(var1, var4) / (float) this.getWidth());
                if (!this.mEdgeGlowBottom.isFinished()) {
                  this.mEdgeGlowBottom.onRelease();
                }
              } else if (var3 > var5) {
                this.mEdgeGlowBottom.onPull(
                    (float) var2 / (float) this.getHeight(),
                    1.0F - MotionEventCompat.getX(var1, var4) / (float) this.getWidth());
                if (!this.mEdgeGlowTop.isFinished()) {
                  this.mEdgeGlowTop.onRelease();
                }
              }

              if (this.mEdgeGlowTop != null
                  && (!this.mEdgeGlowTop.isFinished() || !this.mEdgeGlowBottom.isFinished())) {
                ViewCompat.postInvalidateOnAnimation(this);
              }
            }
          }
        }
        break;
      case 3:
        if (this.mIsBeingDragged && this.getChildCount() > 0) {
          this.mActivePointerId = -1;
          this.endDrag();
        }
      case 4:
      default:
        break;
      case 5:
        var2 = MotionEventCompat.getActionIndex(var1);
        this.mLastMotionY = (int) MotionEventCompat.getY(var1, var2);
        this.mActivePointerId = MotionEventCompat.getPointerId(var1, var2);
        break;
      case 6:
        this.onSecondaryPointerUp(var1);
        this.mLastMotionY =
            (int)
                MotionEventCompat.getY(
                    var1, MotionEventCompat.findPointerIndex(var1, this.mActivePointerId));
    }

    if (this.mVelocityTracker != null) {
      this.mVelocityTracker.addMovement(var9);
    }

    var9.recycle();
    return true;
  }