/* (non-Javadoc) * @see com.google.android.maps.MapView#onTouchEvent(android.view.MotionEvent) */ @Override public boolean onTouchEvent(MotionEvent ev) { int action = ev.getAction(); int t; switch (action) { case MotionEvent.ACTION_DOWN: clicked = true; break; case MotionEvent.ACTION_MOVE: clicked = false; t = ev.getHistorySize(); geoPoint = getProjection().fromPixels((int) ev.getX(t), (int) ev.getY(t)); break; case MotionEvent.ACTION_UP: if (clicked) { t = ev.getHistorySize(); geoPoint = getProjection().fromPixels((int) ev.getX(t), (int) ev.getY(t)); getController().animateTo(geoPoint); invalidate(); // getPositionBtn.setEnabled(true); } break; } // TODO Auto-generated method stub return super.onTouchEvent(ev); }
private void track(MotionEvent event) { mX.saveTouchPos(); mY.saveTouchPos(); for (int i = 0; i < event.getHistorySize(); i++) { track( event.getHistoricalX(0, i), event.getHistoricalY(0, i), event.getHistoricalEventTime(i)); } track(event.getX(0), event.getY(0), event.getEventTime()); if (stopped()) { if (mState == PanZoomState.PANNING) { setState(PanZoomState.PANNING_HOLD); } else if (mState == PanZoomState.PANNING_LOCKED) { setState(PanZoomState.PANNING_HOLD_LOCKED); } else { // should never happen, but handle anyway for robustness Log.e(LOGTAG, "Impossible case " + mState + " when stopped in track"); setState(PanZoomState.PANNING_HOLD_LOCKED); } } mX.startPan(); mY.startPan(); updatePosition(); }
public boolean onTouch(View view, MotionEvent event) { float x = event.getX(); float y = event.getY(); switch (event.getAction()) { case MotionEvent.ACTION_DOWN: path.moveTo(x, y); return true; case MotionEvent.ACTION_UP: case MotionEvent.ACTION_MOVE: l = x; r = x; t = y; b = y; for (int i = 0; i < event.getHistorySize(); i++) { float newX = event.getHistoricalX(i); float newY = event.getHistoricalY(i); path.lineTo(newX, newY); l = newX < l ? newX : l; t = newY < t ? newY : t; r = newX > r ? newX : r; b = newY > b ? newY : b; } rect.set(l, t, r, b); Log.d("TAG", rect.toShortString()); invalidate( (int) rect.left - 5, (int) rect.top - 5, (int) rect.right + 5, (int) rect.bottom + 5); break; default: } return super.onTouchEvent(event); }
@Override public boolean onTouchEvent(MotionEvent event) { float mCurX; float mCurY; // API level 9 and above supports "Major" property on event which // gives // the size of the touch area at the point of contact // so for now we just hard code float TOUCH_AREA_SIZE = penWidth; int action = event.getAction(); if (action != MotionEvent.ACTION_UP && action != MotionEvent.ACTION_CANCEL) { int N = event.getHistorySize(); int P = event.getPointerCount(); for (int i = 0; i < N; i++) { for (int j = 0; j < P; j++) { mCurX = event.getHistoricalX(j, i); mCurY = event.getHistoricalY(j, i); drawPoint(mCurX, mCurY, event.getHistoricalPressure(j, i), TOUCH_AREA_SIZE); } } for (int j = 0; j < P; j++) { mCurX = event.getX(j); mCurY = event.getY(j); drawPoint(mCurX, mCurY, event.getPressure(j), TOUCH_AREA_SIZE); } } unsaved = true; return true; }
// @!ANDROID-4 private static int getAction(int index, MotionEvent event) { int action = event.getAction(); if (action == MotionEvent.ACTION_MOVE) { int hsz = event.getHistorySize(); if (hsz > 0) { if (Math.abs(event.getX(index) - event.getHistoricalX(index, hsz - 1)) > 1 || Math.abs(event.getY(index) - event.getHistoricalY(index, hsz - 1)) > 1) return 1; else return 2; } return 1; } switch (index) { case 0: if (action == MotionEvent.ACTION_DOWN || action == MotionEvent.ACTION_POINTER_1_DOWN) return 0; if (action == MotionEvent.ACTION_UP || action == MotionEvent.ACTION_POINTER_1_UP) return 3; break; case 1: if (action == MotionEvent.ACTION_POINTER_2_DOWN || action == MotionEvent.ACTION_POINTER_DOWN) return 0; if (action == MotionEvent.ACTION_POINTER_2_UP || action == MotionEvent.ACTION_POINTER_UP) return 3; break; case 2: if (action == MotionEvent.ACTION_POINTER_3_DOWN || action == MotionEvent.ACTION_POINTER_DOWN) return 0; if (action == MotionEvent.ACTION_POINTER_3_UP || action == MotionEvent.ACTION_POINTER_UP) return 3; break; } return 2; }
@Override public boolean onTouchEvent(final ViewGroup view, final MotionEvent event) { if (mIsVerticalScrolling && !mController.isScrolling() || mShouldDisableScroll) return true; switch (event.getAction()) { case MotionEvent.ACTION_DOWN: { mTempDeltaX = 0; mTotalMoveX = 0; mTotalMoveY = 0; mActualMoveX = 0; mIsVerticalScrolling = false; mController.reset(); break; } case MotionEvent.ACTION_MOVE: { final int hist_size = event.getHistorySize(); if (hist_size == 0) { break; } final float distanceX = mTempDeltaX = event.getX() - event.getHistoricalX(0); mActualMoveX = mTotalMoveX += mTempDeltaX; mController.scrollBy((int) -distanceX); break; } } return true; }
// The following methods are taken from the controller sample on the // Android Developer web site: // https://developer.android.com/training/game-controllers/controller-input.html private void dispatchMotionEvent(int id, MotionEvent event) { if (id != -1) { final int historySize = event.getHistorySize(); for (int i = 0; i < historySize; i++) { processMouseInput(id, event, i); } processMouseInput(id, event, -1); } }
/** * Extracts the touch point data from a MotionEvent, converts each point into a marshallable * object and passes the set of points to the JNI layer to be transmitted to the remote host. * * @param event The event to send to the remote host for injection. NOTE: This object must be * updated to represent the remote machine's coordinate system before calling this function. */ public void sendTouchEvent(MotionEvent event) { int action = event.getActionMasked(); TouchEventData.EventType touchEventType = TouchEventData.EventType.fromMaskedAction(action); List<TouchEventData> touchEventList = new ArrayList<TouchEventData>(); if (action == MotionEvent.ACTION_MOVE) { // In order to process all of the events associated with an ACTION_MOVE event, we need // to walk the list of historical events in order and add each event to our list, then // retrieve the current move event data. int pointerCount = event.getPointerCount(); int historySize = event.getHistorySize(); for (int h = 0; h < historySize; ++h) { for (int p = 0; p < pointerCount; ++p) { touchEventList.add( new TouchEventData( event.getPointerId(p), event.getHistoricalX(p, h), event.getHistoricalY(p, h), event.getHistoricalSize(p, h), event.getHistoricalSize(p, h), event.getHistoricalOrientation(p, h), event.getHistoricalPressure(p, h))); } } for (int p = 0; p < pointerCount; p++) { touchEventList.add( new TouchEventData( event.getPointerId(p), event.getX(p), event.getY(p), event.getSize(p), event.getSize(p), event.getOrientation(p), event.getPressure(p))); } } else { // For all other events, we only want to grab the current/active pointer. The event // contains a list of every active pointer but passing all of of these to the host can // cause confusion on the remote OS side and result in broken touch gestures. int activePointerIndex = event.getActionIndex(); touchEventList.add( new TouchEventData( event.getPointerId(activePointerIndex), event.getX(activePointerIndex), event.getY(activePointerIndex), event.getSize(activePointerIndex), event.getSize(activePointerIndex), event.getOrientation(activePointerIndex), event.getPressure(activePointerIndex))); } if (!touchEventList.isEmpty()) { mInjector.sendTouchEvent(touchEventType, touchEventList.toArray(new TouchEventData[0])); } }
@Override public boolean onTouchEvent(MotionEvent event) { float mCurX; float mCurY; ArrayList<Point> eraserpoints = new ArrayList<Point>(); int action = event.getAction(); if (action != MotionEvent.ACTION_UP && action != MotionEvent.ACTION_CANCEL) { // Log.d(TAG, "PEN UP"); } if (action == MotionEvent.ACTION_DOWN) { // start recording points mCurrentPath = new Path(); mCurrentPath.moveTo(event.getX(), event.getY()); } if (action == MotionEvent.ACTION_MOVE) { // start recording points int N = event.getHistorySize(); int P = event.getPointerCount(); for (int i = 0; i < N; i++) { for (int j = 0; j < P; j++) { mCurX = event.getHistoricalX(j, i); mCurY = event.getHistoricalY(j, i); if (mEraserMode == true) { if (eraserpoints != null) { eraserpoints.add(new Point(Math.round(mCurX), Math.round(mCurY))); } else { Log.e(TAG, "no eraserpoints array defined, skipping adding erase point"); } } else { if (mCurrentPath != null) { mCurrentPath.lineTo(mCurX, mCurY); } else { Log.e(TAG, "NO PATH TO ADD POINT" + mCurX + "," + mCurY); } } } } if (mCurrentPath != null) { mCurrentPath.lineTo(event.getX(), event.getY()); mCanvas.drawPath(mCurrentPath, (mEraserMode == true ? mEraserPainter : mPenPainter)); invalidate(); } else { Log.e(TAG, "Missing CurrentPath object"); } } mUnsaved = true; return true; }
public void c(MotionEvent paramMotionEvent) { int j = paramMotionEvent.getHistorySize(); int i = 0; while (i < j) { a( paramMotionEvent.getActionMasked(), paramMotionEvent.getHistoricalX(0, i), paramMotionEvent.getHistoricalY(0, i)); i += 1; } a(paramMotionEvent.getActionMasked(), paramMotionEvent.getX(), paramMotionEvent.getY()); }
@Override public boolean onTouch(final View view, final MotionEvent event) { switch (event.getAction()) { case MotionEvent.ACTION_DOWN: { mTempDeltaX = 0; mTotalMoveX = 0; mIsScrolling = false; // final View layout = mParent.getRightPaneLayout(); mShouldDisableScroll = !(mContext instanceof DualPaneActivity && ((DualPaneActivity) mContext).isRightPaneUsed()); if (!mShouldDisableScroll) { mController.reset(); } else return false; break; } case MotionEvent.ACTION_MOVE: { if (mShouldDisableScroll) return false; final int hist_size = event.getHistorySize(); if (hist_size == 0) { break; } final float distanceX = mTempDeltaX = event.getX() - event.getHistoricalX(0); mTotalMoveX += mTempDeltaX; if (Math.abs(mTotalMoveX) >= mScaledTouchSlop) { mIsScrolling = true; } if (mIsScrolling) { mController.scrollBy((int) -distanceX); } break; } case MotionEvent.ACTION_UP: { if (mIsScrolling) { mController.release(-mTempDeltaX, -mTotalMoveX); } mTempDeltaX = 0; mTotalMoveX = 0; mIsScrolling = false; if (mShouldDisableScroll) { mShouldDisableScroll = false; return false; } mShouldDisableScroll = false; break; } } return true; }
protected MotionEvent createLongLeftMoveEvent() { MotionEvent event = mock(MotionEvent.class); when(event.getAction()).thenReturn(MotionEvent.ACTION_MOVE); when(event.getX()).thenReturn(50f); when(event.getY()).thenReturn(150f); when(event.getX(0)).thenReturn(50f); when(event.getY(0)).thenReturn(150f); when(event.getHistorySize()).thenReturn(1); when(event.getHistoricalX(eq(0))).thenReturn(100f); when(event.getHistoricalY(eq(0))).thenReturn(200f); when(event.getHistoricalX(eq(0), eq(0))).thenReturn(100f); when(event.getHistoricalY(eq(0), eq(0))).thenReturn(200f); return event; }
@Override public boolean onTouchEvent(MotionEvent event) { float eventX = event.getX(); float eventY = event.getY(); switch (event.getAction()) { case MotionEvent.ACTION_DOWN: path.moveTo(eventX, eventY); lastTouchX = eventX; lastTouchY = eventY; // There is no end point yet, so don't waste cycles invalidating. return true; case MotionEvent.ACTION_MOVE: case MotionEvent.ACTION_UP: // Start tracking the dirty region. resetDirtyRect(eventX, eventY); // When the hardware tracks events faster than they are delivered, the // event will contain a history of those skipped points. int historySize = event.getHistorySize(); for (int i = 0; i < historySize; i++) { float historicalX = event.getHistoricalX(i); float historicalY = event.getHistoricalY(i); expandDirtyRect(historicalX, historicalY); path.lineTo(historicalX, historicalY); } // After replaying history, connect the line to the touch point. path.lineTo(eventX, eventY); break; default: Log.d("default", "Ignored touch event: " + event.toString()); return false; } // Include half the stroke width to avoid clipping. invalidate( (int) (dirtyRect.left - HALF_STROKE_WIDTH), (int) (dirtyRect.top - HALF_STROKE_WIDTH), (int) (dirtyRect.right + HALF_STROKE_WIDTH), (int) (dirtyRect.bottom + HALF_STROKE_WIDTH)); lastTouchX = eventX; lastTouchY = eventY; return true; }
/** * Add a user's movement to the tracker. You should call this for the initial {@link * MotionEvent#ACTION_DOWN}, the following {@link MotionEvent#ACTION_MOVE} events that you * receive, and the final {@link MotionEvent#ACTION_UP}. You can, however, call this for whichever * events you desire. * * @param ev The MotionEvent you received and would like to track. */ public void addMovement(MotionEvent ev) { final int mN = ev.getHistorySize(); if (++mLastTouch >= NUM_PAST) { mLastTouch = 0; } for (int i = 0; i < mN; ++i) { mPastX[mLastTouch] = ev.getHistoricalX(i); mPastY[mLastTouch] = ev.getHistoricalY(i); mPastTime[mLastTouch] = ev.getHistoricalEventTime(i); if (++mLastTouch >= NUM_PAST) { mLastTouch = 0; } } mPastX[mLastTouch] = ev.getX(); mPastY[mLastTouch] = ev.getY(); mPastTime[mLastTouch] = ev.getEventTime(); }
@Override public boolean onTouchEvent(MotionEvent event) { float eventX = event.getX(); float eventY = event.getY(); switch (event.getAction()) { case MotionEvent.ACTION_DOWN: path.moveTo(eventX, eventY); lastTouchX = eventX; lastTouchY = eventY; return true; case MotionEvent.ACTION_MOVE: case MotionEvent.ACTION_UP: resetDirtyRect(eventX, eventY); int historySize = event.getHistorySize(); for (int i = 0; i < historySize; i++) { float historicalX = event.getHistoricalX(i); float historicalY = event.getHistoricalY(i); expandDirtyRect(historicalX, historicalY); path.lineTo(historicalX, historicalY); } path.lineTo(eventX, eventY); break; default: return false; } invalidate( (int) (dirtyRect.left - HALF_STROKE_WIDTH), (int) (dirtyRect.top - HALF_STROKE_WIDTH), (int) (dirtyRect.right + HALF_STROKE_WIDTH), (int) (dirtyRect.bottom + HALF_STROKE_WIDTH)); lastTouchX = eventX; lastTouchY = eventY; return true; }
@Override public boolean onInterceptTouchEvent(final ViewGroup view, final MotionEvent event) { mShouldDisableScroll = !(isTouchEventHandled(view, event) || mContext instanceof DualPaneActivity && ((DualPaneActivity) mContext).isRightPaneUsed()); switch (event.getAction()) { case MotionEvent.ACTION_DOWN: { mFirstDownHandled = !mShouldDisableScroll; mTempDeltaX = 0; mTotalMoveX = 0; mTotalMoveY = 0; mActualMoveX = 0; mIsVerticalScrolling = false; if (mFirstDownHandled) { mParent.animateOpen(); } break; } case MotionEvent.ACTION_MOVE: { final int hist_size = event.getHistorySize(); if (hist_size == 0) { break; } mTempDeltaX = event.getX() - event.getHistoricalX(0); mTotalMoveX += mTempDeltaX; final float deltaY = event.getY() - event.getHistoricalY(0); mTotalMoveY += deltaY; if (Math.abs(mTempDeltaX) > Math.abs(deltaY) && !mIsVerticalScrolling && Math.abs(mTotalMoveX) >= mScaledTouchSlop) return true; if (Math.abs(mTempDeltaX) < Math.abs(deltaY) && Math.abs(mTotalMoveY) >= mScaledTouchSlop) { mIsVerticalScrolling = true; return false; } break; } } return false; }
/** * adjust header padding according to motion event * * @param ev */ private void adjustHeaderPadding(MotionEvent ev) { // adjust header padding according to motion event history int pointerCount = ev.getHistorySize(); if (isVerticalFadingEdgeEnabled()) { setVerticalScrollBarEnabled(false); } for (int i = 0; i < pointerCount; i++) { if (currentHeaderStatus == HEADER_STATUS_DROP_DOWN_TO_LOAD || currentHeaderStatus == HEADER_STATUS_RELEASE_TO_LOAD) { headerLayout.setPadding( headerLayout.getPaddingLeft(), (int) (((ev.getHistoricalY(i) - actionDownPointY) - headerOriginalHeight) / headerPaddingTopRate), headerLayout.getPaddingRight(), headerLayout.getPaddingBottom()); } } }
@Override public boolean onTouchEvent(MotionEvent event) { //// System.out.println("flipStarted" + flipStarted); if (flipStarted) { return false; } // if (header.isSourceSelectMode()) { // header.onTouchEvent(event); // } if (enlargedMode) { current.onTouchEvent(event); } switch (event.getAction()) { case MotionEvent.ACTION_MOVE: if (event.getHistorySize() > 0 && !flipStarted) { if (GestureUtil.flipRight(event)) { lastFlipDirection = ACTION_HORIZONTAL; flipPage(false); } else if (GestureUtil.flipUp(event)) { lastFlipDirection = ACTION_VERTICAL; flipPage(false); } else if (GestureUtil.flipLeft(event)) { lastFlipDirection = ACTION_HORIZONTAL; flipPage(true); } else if (GestureUtil.flipDown(event)) { lastFlipDirection = ACTION_VERTICAL; flipPage(true); } } else { // if (header.isSourceSelectMode()) header.onTouchEvent(event); // pageIndexView.onTouchEvent(event); } break; default: break; } return true; }
/** * Process trackball events. Used mainly for fine-tuned color adjustment, or alternatively to * switch between slider controls. */ @Override public boolean dispatchTrackballEvent(MotionEvent event) { float x = event.getX(); float y = event.getY(); // A longer event history implies faster trackball movement. // Use it to infer a larger jump and therefore faster palette/slider adjustment. int jump = event.getHistorySize() + 1; switch (event.getAction()) { case MotionEvent.ACTION_DOWN: { } break; case MotionEvent.ACTION_MOVE: { // NEW_METHOD_WORK_NEEDED_HERE // To add a new method, replicate and extend the appropriate entry in this list, // depending on whether you use 1D or 2D controllers switch (mMethod) { case METHOD_HS_V_PALETTE: if (mFocusedControl == 0) { changeHSPalette(x, y, jump); } else if (mFocusedControl == 1) { if (y < 0) changeSlider(mFocusedControl, true, jump); else if (y > 0) changeSlider(mFocusedControl, false, jump); } break; } } break; case MotionEvent.ACTION_UP: { } break; } return true; }
private void applyHeaderPadding(MotionEvent ev) { // getHistorySize has been available since API 1 int pointerCount = ev.getHistorySize(); for (int p = 0; p < pointerCount; p++) { if (mRefreshState == RELEASE_TO_REFRESH) { if (isVerticalFadingEdgeEnabled()) { setVerticalScrollBarEnabled(false); } int historicalY = (int) ev.getHistoricalY(p); // Calculate the padding to apply, we divide by 1.7 to // simulate a more resistant effect during pull. int topPadding = (int) (((historicalY - mLastMotionY) - mRefreshViewHeight) / 1.7); mRefreshView.setPadding( mRefreshView.getPaddingLeft(), topPadding, mRefreshView.getPaddingRight(), mRefreshView.getPaddingBottom()); } } }
private int detectSwipe(MotionEvent move) { final int historySize = move.getHistorySize(); final int pointerCount = move.getPointerCount(); for (int p = 0; p < pointerCount; p++) { final int pointerId = move.getPointerId(p); final int i = findIndex(pointerId); if (i != UNTRACKED_POINTER) { for (int h = 0; h < historySize; h++) { final long time = move.getHistoricalEventTime(h); final float x = move.getHistoricalX(p, h); final float y = move.getHistoricalY(p, h); final int swipe = detectSwipe(i, time, x, y); if (swipe != SWIPE_NONE) { return swipe; } } final int swipe = detectSwipe(i, move.getEventTime(), move.getX(p), move.getY(p)); if (swipe != SWIPE_NONE) { return swipe; } } } return SWIPE_NONE; }
private void handleActionMove(MotionEvent event) { // Handle all recent motion events so we don't skip any cells even when the device // is busy... final int historySize = event.getHistorySize(); for (int i = 0; i < historySize + 1; i++) { final float x = i < historySize ? event.getHistoricalX(i) : event.getX(); final float y = i < historySize ? event.getHistoricalY(i) : event.getY(); final int patternSizePreHitDetect = mPattern.size(); Cell hitCell = detectAndAddHit(x, y); final int patternSize = mPattern.size(); if (hitCell != null && patternSize == 1) { mPatternInProgress = true; notifyPatternStarted(); } // note current x and y for rubber banding of in progress patterns final float dx = Math.abs(x - mInProgressX); final float dy = Math.abs(y - mInProgressY); if (dx + dy > mSquareWidth * 0.01f) { float oldX = mInProgressX; float oldY = mInProgressY; mInProgressX = x; mInProgressY = y; if (mPatternInProgress && patternSize > 0) { final ArrayList<Cell> pattern = mPattern; final float radius = mSquareWidth * mDiameterFactor * 0.5f; final Cell lastCell = pattern.get(patternSize - 1); float startX = getCenterXForColumn(lastCell.column); float startY = getCenterYForRow(lastCell.row); float left; float top; float right; float bottom; final Rect invalidateRect = mInvalidate; if (startX < x) { left = startX; right = x; } else { left = x; right = startX; } if (startY < y) { top = startY; bottom = y; } else { top = y; bottom = startY; } // Invalidate between the pattern's last cell and the current location invalidateRect.set( (int) (left - radius), (int) (top - radius), (int) (right + radius), (int) (bottom + radius)); if (startX < oldX) { left = startX; right = oldX; } else { left = oldX; right = startX; } if (startY < oldY) { top = startY; bottom = oldY; } else { top = oldY; bottom = startY; } // Invalidate between the pattern's last cell and the previous location invalidateRect.union( (int) (left - radius), (int) (top - radius), (int) (right + radius), (int) (bottom + radius)); // Invalidate between the pattern's new cell and the pattern's previous cell if (hitCell != null) { startX = getCenterXForColumn(hitCell.column); startY = getCenterYForRow(hitCell.row); if (patternSize >= 2) { // (re-using hitcell for old cell) hitCell = pattern.get(patternSize - 1 - (patternSize - patternSizePreHitDetect)); oldX = getCenterXForColumn(hitCell.column); oldY = getCenterYForRow(hitCell.row); if (startX < oldX) { left = startX; right = oldX; } else { left = oldX; right = startX; } if (startY < oldY) { top = startY; bottom = oldY; } else { top = oldY; bottom = startY; } } else { left = right = startX; top = bottom = startY; } final float widthOffset = mSquareWidth / 2f; final float heightOffset = mSquareHeight / 2f; invalidateRect.set( (int) (left - widthOffset), (int) (top - heightOffset), (int) (right + widthOffset), (int) (bottom + heightOffset)); } invalidate(invalidateRect); } else { invalidate(); } } } }
private void handleMove(MotionEvent event) { int activeTarget = -1; final int historySize = event.getHistorySize(); ArrayList<TargetDrawable> targets = mTargetDrawables; int ntargets = targets.size(); float x = 0.0f; float y = 0.0f; int actionIndex = event.findPointerIndex(mPointerId); if (actionIndex == -1) { return; // no data for this pointer } for (int k = 0; k < historySize + 1; k++) { float eventX = k < historySize ? event.getHistoricalX(actionIndex, k) : event.getX(actionIndex); float eventY = k < historySize ? event.getHistoricalY(actionIndex, k) : event.getY(actionIndex); // tx and ty are relative to wave center float tx = eventX - mWaveCenterX; float ty = eventY - mWaveCenterY; float touchRadius = (float) Math.sqrt(dist2(tx, ty)); final float scale = touchRadius > mOuterRadius ? mOuterRadius / touchRadius : 1.0f; float limitX = tx * scale; float limitY = ty * scale; double angleRad = Math.atan2(-ty, tx); if (!mDragging) { trySwitchToFirstTouchState(eventX, eventY); } if (mDragging) { // For multiple targets, snap to the one that matches final float snapRadius = mRingScaleFactor * mOuterRadius - mSnapMargin; final float snapDistance2 = snapRadius * snapRadius; // Find first target in range for (int i = 0; i < ntargets; i++) { TargetDrawable target = targets.get(i); double targetMinRad = (i - 0.5) * 2 * Math.PI / ntargets; double targetMaxRad = (i + 0.5) * 2 * Math.PI / ntargets; if (target.isEnabled()) { boolean angleMatches = (angleRad > targetMinRad && angleRad <= targetMaxRad) || (angleRad + 2 * Math.PI > targetMinRad && angleRad + 2 * Math.PI <= targetMaxRad); if (angleMatches && (dist2(tx, ty) > snapDistance2)) { activeTarget = i; } } } } x = limitX; y = limitY; } if (!mDragging) { return; } if (activeTarget != -1) { switchToState(STATE_SNAP, x, y); updateGlowPosition(x, y); } else { switchToState(STATE_TRACKING, x, y); updateGlowPosition(x, y); } if (mActiveTarget != activeTarget) { // Defocus the old target if (mActiveTarget != -1) { TargetDrawable target = targets.get(mActiveTarget); target.setState(TargetDrawable.STATE_INACTIVE); } // Focus the new target if (activeTarget != -1) { TargetDrawable target = targets.get(activeTarget); target.setState(TargetDrawable.STATE_FOCUSED); final AccessibilityManager accessibilityManager = (AccessibilityManager) getContext().getSystemService(Context.ACCESSIBILITY_SERVICE); if (accessibilityManager.isEnabled()) { String targetContentDescription = getTargetDescription(activeTarget); announceForAccessibility(targetContentDescription); } } } mActiveTarget = activeTarget; }
@Override public boolean onTouchEvent(MotionEvent event) { int action = event.getAction(); switch (action) { case MotionEvent.ACTION_DOWN: downX = event.getX(); downY = event.getY(); if (mPropagateClicks) propagatePressed(true); break; case MotionEvent.ACTION_MOVE: try { if (mPropagateClicks) { float xDeltaTotal = event.getX() - downX; float yDeltaTotal = event.getY() - downY; if (Math.abs(xDeltaTotal) >= CLICK_SENSITIVITY || Math.abs(yDeltaTotal) >= CLICK_SENSITIVITY) { propagatePressed(false); } } float xDelta = event.getX() - downX; float yDelta = event.getY() - downY; if (event.getHistorySize() > 0) { xDelta = event.getX() - event.getHistoricalX(0); yDelta = event.getY() - event.getHistoricalY(0); } if (Math.abs(xDelta) > Math.abs(yDelta)) { if (xDelta > 0 && getCurrentItem() == 0 && mPositionOffset == 0) { return false; } else if (xDelta < 0 && mPositionOffset == 0) { if (getAdapter() != null) { int current = getCurrentItem(); int count = getAdapter().getCount(); if (current >= (count - 1)) { return false; } } } NestedViewPager.this.getParent().requestDisallowInterceptTouchEvent(true); } } catch (Exception e) { // nothing } break; case MotionEvent.ACTION_UP: if (mPropagateClicks) { propagatePressed(false); float xDelta = event.getX() - downX; float yDelta = event.getY() - downY; if (Math.abs(xDelta) < CLICK_SENSITIVITY && Math.abs(yDelta) < CLICK_SENSITIVITY) { propagateClicked(); } } break; } return super.onTouchEvent(event); }