Java MotionEvent.obtain方法代碼示例

import android.view.MotionEvent; //導入方法依賴的package包/類
@Override
protected void handleStartProgressEvent(int actionCode, MotionEvent event){
    switch (actionCode) { 
        case MotionEvent.ACTION_DOWN: 
            resetState(); // In case we missed an UP/CANCEL event
            
            mPrevEvent = MotionEvent.obtain(event);
            mTimeDelta = 0;

            updateStateByEvent(event);
            break;
        
        case MotionEvent.ACTION_MOVE:
            mGestureInProgress = mListener.onMoveBegin(this);
            break;
    }
}
 

import android.view.MotionEvent; //導入方法依賴的package包/類
@Test
public void testSwipeRight_ShouldCallKeepOnListener() throws Exception {
    long downTime = 0;
    long moveTime = downTime + 500;
    long upTime = downTime + 1000;
    float xStart = 200;
    float yStart = 200;
    float xEnd = 500;
    float yEnd = 250;

    MotionEvent e1 = MotionEvent.obtain(downTime, moveTime, MotionEvent.ACTION_MOVE, xStart, yStart, 0);
    MotionEvent e2 = MotionEvent.obtain(downTime, upTime, MotionEvent.ACTION_UP, xEnd, yEnd, 0);
    float velocityX = 120;

    detector.onFling(e1, e2, velocityX, 0);
    verify(listener).onKeep();
}
 

import android.view.MotionEvent; //導入方法依賴的package包/類
private static boolean canScrollDown(View targetView, MotionEvent event) {
    if (canScrollDown(targetView)) {
        return true;
    }
    if (targetView instanceof ViewGroup && event != null) {
        ViewGroup viewGroup = (ViewGroup) targetView;
        final int childCount = viewGroup.getChildCount();
        PointF point = new PointF();
        for (int i = 0; i < childCount; i++) {
            View child = viewGroup.getChildAt(i);
            if (isTransformedTouchPointInView(viewGroup,child, event.getX(), event.getY() , point)) {
                event = MotionEvent.obtain(event);
                event.offsetLocation(point.x, point.y);
                return canScrollDown(child, event);
            }
        }
    }
    return false;
}
 

import android.view.MotionEvent; //導入方法依賴的package包/類
@Override
public boolean dispatchTouchEvent(MotionEvent ev) {
    boolean ret = false;
    // Make sure that the infoWindow is shown and we have all the needed references
    if (marker != null && marker.isInfoWindowShown() && map != null && infoWindow != null) {
        // Get a marker position on the screen
        Point point = map.getProjection().toScreenLocation(marker.getPosition());

        // Make a copy of the MotionEvent and adjust it's location
        // so it is relative to the infoWindow left top corner
        MotionEvent copyEv = MotionEvent.obtain(ev);
        copyEv.offsetLocation(
                -point.x + (infoWindow.getWidth() / 2),
                -point.y + infoWindow.getHeight() + bottomOffsetPixels);

        // Dispatch the adjusted MotionEvent to the infoWindow
        ret = infoWindow.dispatchTouchEvent(copyEv);
    }
    // If the infoWindow consumed the touch event, then just return true.
    // Otherwise pass this event to the super class and return it's result
    return ret || super.dispatchTouchEvent(ev);
}
 

import android.view.MotionEvent; //導入方法依賴的package包/類
public static boolean canScrollDown(View targetView, MotionEvent event) {
    if (canScrollDown(targetView) && targetView.getVisibility() == View.VISIBLE) {
        return true;
    }
    //event == null 時 canScrollDown 不會動態遞歸搜索
    if (targetView instanceof ViewGroup && event != null) {
        ViewGroup viewGroup = (ViewGroup) targetView;
        final int childCount = viewGroup.getChildCount();
        PointF point = new PointF();
        for (int i = 0; i < childCount; i++) {
            View child = viewGroup.getChildAt(i);
            if (isTransformedTouchPointInView(viewGroup, child, event.getX(), event.getY(), point)) {
                event = MotionEvent.obtain(event);
                event.offsetLocation(point.x, point.y);
                return canScrollDown(child, event);
            }
        }
    }
    return false;
}
 

import android.view.MotionEvent; //導入方法依賴的package包/類
/**
 * Start a fake drag of the pager.
 * <p/>
 * <p>A fake drag can be useful if you want to synchronize the motion of the ViewPager
 * with the touch scrolling of another view, while still letting the ViewPager
 * control the snapping motion and fling behavior. (e.g. parallax-scrolling tabs.)
 * Call {@link #fakeDragBy(float)} to simulate the actual drag motion. Call
 * {@link #endFakeDrag()} to complete the fake drag and fling as necessary.
 * <p/>
 * <p>During a fake drag the ViewPager will ignore all touch events. If a real drag
 * is already in progress, this method will return false.
 *
 * @return true if the fake drag began successfully, false if it could not be started.
 * @see #fakeDragBy(float)
 * @see #endFakeDrag()
 */
public boolean beginFakeDrag() {
    if (mIsBeingDragged) {
        return false;
    }
    mFakeDragging = true;
    setScrollState(SCROLL_STATE_DRAGGING);
    if (isHorizontalDirection()) {
        mInitialMotionX = mLastMotionX = 0;
    } else if (isVerticalDirection()) {
        mInitialMotionY = mLastMotionY = 0;
    }
    if (mVelocityTracker == null) {
        mVelocityTracker = VelocityTracker.obtain();
    } else {
        mVelocityTracker.clear();
    }
    final long time = SystemClock.uptimeMillis();
    final MotionEvent ev = MotionEvent.obtain(time, time, MotionEvent.ACTION_DOWN, 0, 0, 0);
    mVelocityTracker.addMovement(ev);
    ev.recycle();
    mFakeDragBeginTime = time;
    return true;
}
 

import android.view.MotionEvent; //導入方法依賴的package包/類
@Override
public boolean onTouchEvent(@NonNull MotionEvent event) {
    if (mRecyclerWantsTouchEvent) {
        int scrollDiff = mCurrentScroll - mDownScroll;
        MotionEvent recyclerEvent =
                MotionEvent.obtain(event.getDownTime(), event.getEventTime(), event.getAction(),
                        event.getX(), event.getY() - scrollDiff, event.getMetaState());
        mRecycler.onTouchEvent(recyclerEvent);
        return false;
    }
    return super.onTouchEvent(event);
}
 

import android.view.MotionEvent; //導入方法依賴的package包/類
private void fakeDragByHorizontally(float xOffset) {
    mLastMotionX += xOffset;

    float oldScrollX = getScrollX();
    float scrollX = oldScrollX - xOffset;
    final int width = getClientWidth();

    float leftBound = width * mFirstOffset;
    float rightBound = width * mLastOffset;

    final ItemInfo firstItem = mItems.get(0);
    final ItemInfo lastItem = mItems.get(mItems.size() - 1);
    if (firstItem.position != 0) {
        leftBound = firstItem.offset * width;
    }
    if (lastItem.position != mAdapter.getCount() - 1) {
        rightBound = lastItem.offset * width;
    }

    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());
    pageScrolledHorizontally((int) scrollX);

    // Synthesize an event for the VelocityTracker.
    final long time = SystemClock.uptimeMillis();
    final MotionEvent ev = MotionEvent.obtain(mFakeDragBeginTime, time, MotionEvent.ACTION_MOVE,
            mLastMotionX, 0, 0);
    mVelocityTracker.addMovement(ev);
    ev.recycle();
}
 

import android.view.MotionEvent; //導入方法依賴的package包/類
public static MotionEvent obtainMotionEvent(
    long downTime,
    long eventTime,
    int action,
    int id1,
    float x1,
    float y1) {
  int[] ids = new int[] {id1};
  MotionEvent.PointerCoords[] coords = new MotionEvent.PointerCoords[] {createCoords(x1, y1)};
  return MotionEvent
      .obtain(downTime, eventTime, action, 1, ids, coords, 0, 1.0f, 1.0f, 0, 0, 0, 0);
}
 

import android.view.MotionEvent; //導入方法依賴的package包/類
@Test
public void testOnTouchEvent() throws Exception {
  for(int action:EVENTS) {
    MotionEvent event = MotionEvent.obtain(100, 100, action,
        10, 10, 0);
    view.onTouchEvent(event);
    event.recycle();
  }
}
 

import android.view.MotionEvent; //導入方法依賴的package包/類
@Override
public boolean dispatchTouchEvent(MotionEvent ev) {

  final float x = ev.getX();
  final float y = ev.getY();
  final int action = ev.getAction();

  if (action == MotionEvent.ACTION_DOWN
      && mTouchTarget == null
      && mPinnedSection != null
      && isPinnedViewTouched(mPinnedSection.view, x, y)) { // create touch target

    // user touched pinned view
    mTouchTarget = mPinnedSection.view;
    mTouchPoint.x = x;
    mTouchPoint.y = y;

    // copy down event for eventually be used later
    mDownEvent = MotionEvent.obtain(ev);
  }

  if (mTouchTarget != null) {
    if (isPinnedViewTouched(mTouchTarget, x, y)) { // forward event to pinned view
      mTouchTarget.dispatchTouchEvent(ev);
    }

    if (action == MotionEvent.ACTION_UP) { // perform onClick on pinned view
      super.dispatchTouchEvent(ev);
      performPinnedItemClick();
      clearTouchTarget();

    } else if (action == MotionEvent.ACTION_CANCEL) { // cancel
      clearTouchTarget();

    } else if (action == MotionEvent.ACTION_MOVE) {
      if (Math.abs(y - mTouchPoint.y) > mTouchSlop) {

        // cancel sequence on touch target
        MotionEvent event = MotionEvent.obtain(ev);
        event.setAction(MotionEvent.ACTION_CANCEL);
        mTouchTarget.dispatchTouchEvent(event);
        event.recycle();

        // provide correct sequence to super class for further handling
        super.dispatchTouchEvent(mDownEvent);
        super.dispatchTouchEvent(ev);
        clearTouchTarget();

      }
    }

    return true;
  }

  // call super if this was not our pinned view
  return super.dispatchTouchEvent(ev);
}
 

import android.view.MotionEvent; //導入方法依賴的package包/類
/**
 * Enable or disable layout and scroll.  After <code>setLayoutFrozen(true)</code> is called,
 * Layout requests will be postponed until <code>setLayoutFrozen(false)</code> is called;
 * child views are not updated when RecyclerView is frozen, {@link #smoothScrollBy(int, int)},
 * {@link #scrollBy(int, int)}, {@link #scrollToPosition(int)} and
 * {@link #smoothScrollToPosition(int)} are dropped; TouchEvents and GenericMotionEvents are
 * dropped; {@link LayoutManager#onFocusSearchFailed(View, int, Recycler, State)} will not be
 * called.
 *
 * <p>
 * <code>setLayoutFrozen(true)</code> does not prevent app from directly calling {@link
 * LayoutManager#scrollToPosition(int)}, {@link LayoutManager#smoothScrollToPosition(
 * RecyclerView, State, int)}.
 * <p>
 * {@link #setAdapter(Adapter)} and {@link #swapAdapter(Adapter, boolean)} will automatically
 * stop frozen.
 * <p>
 * Note: Running ItemAnimator is not stopped automatically,  it's caller's
 * responsibility to call ItemAnimator.end().
 *
 * @param frozen   true to freeze layout and scroll, false to re-enable.
 */
public void setLayoutFrozen(boolean frozen) {
    if (frozen != mLayoutFrozen) {
        assertNotInLayoutOrScroll("Do not setLayoutFrozen in layout or scroll");
        if (!frozen) {
            mLayoutFrozen = false;
            if (mLayoutRequestEaten && mLayout != null && mAdapter != null) {
                requestLayout();
            }
            mLayoutRequestEaten = false;
        } else {
            final long now = SystemClock.uptimeMillis();
            MotionEvent cancelEvent = MotionEvent.obtain(now, now,
                    MotionEvent.ACTION_CANCEL, 0.0f, 0.0f, 0);
            onTouchEvent(cancelEvent);
            mLayoutFrozen = true;
            mIgnoreMotionEventTillDown = true;
            stopScroll();
        }
    }
}
 

import android.view.MotionEvent; //導入方法依賴的package包/類
@Override
public void onActionDown(MotionEvent e) {
    mMotionEvent = MotionEvent.obtain(e);
    mMotionEvent.offsetLocation(-mContentView.getLeft(), -mContentView.getTop());
}
 

import android.view.MotionEvent; //導入方法依賴的package包/類
@Override
public boolean onTouchEvent(MotionEvent me) {
    // Convert multi-pointer up/down events to single up/down events to
    // deal with the typical multi-pointer behavior of two-thumb typing
    final int pointerCount = me.getPointerCount();
    final int action = me.getAction();
    boolean result = false;
    final long now = me.getEventTime();

    if (pointerCount != mOldPointerCount) {
        if (pointerCount == 1) {
            // Send a down event for the latest pointer
            MotionEvent down = MotionEvent.obtain(now, now, MotionEvent.ACTION_DOWN,
                    me.getX(), me.getY(), me.getMetaState());
            result = onModifiedTouchEvent(down, false);
            down.recycle();
            // If it's an up action, then deliver the up as well.
            if (action == MotionEvent.ACTION_UP) {
                result = onModifiedTouchEvent(me, true);
            }
        } else {
            // Send an up event for the last pointer
            MotionEvent up = MotionEvent.obtain(now, now, MotionEvent.ACTION_UP,
                    mOldPointerX, mOldPointerY, me.getMetaState());
            result = onModifiedTouchEvent(up, true);
            up.recycle();
        }
    } else {
        if (pointerCount == 1) {
            result = onModifiedTouchEvent(me, false);
            mOldPointerX = me.getX();
            mOldPointerY = me.getY();
        } else {
            // Don't do anything when 2 pointers are down and moving.
            result = true;
        }
    }
    mOldPointerCount = pointerCount;

    return result;
}
 

import android.view.MotionEvent; //導入方法依賴的package包/類
private void cancelSuperTouch(MotionEvent ev) {
    MotionEvent cancel = MotionEvent.obtain(ev);
    cancel.setAction(3);
    super.onTouchEvent(cancel);
    cancel.recycle();
}