/**
   * 描述:TODO
   *
   * @see android.view.View#onKeyUp(int, android.view.KeyEvent)
   * @author: zhaoqp
   * @date:2013-11-28 上午11:14:35
   * @version v1.0
   */
  @Override
  public boolean onKeyUp(int keyCode, KeyEvent event) {
    switch (keyCode) {
      case KeyEvent.KEYCODE_DPAD_CENTER:
      case KeyEvent.KEYCODE_ENTER:
        {
          if (mReceivedInvokeKeyDown) {
            if (mItemCount > 0) {

              dispatchPress(mSelectedChild);
              postDelayed(
                  new Runnable() {
                    public void run() {
                      dispatchUnpress();
                    }
                  },
                  ViewConfiguration.getPressedStateDuration());

              int selectedIndex = mSelectedPosition - mFirstPosition;
              performItemClick(
                  getChildAt(selectedIndex),
                  mSelectedPosition,
                  mAdapter.getItemId(mSelectedPosition));
            }
          }

          // Clear the flag
          mReceivedInvokeKeyDown = false;

          return true;
        }
    }

    return super.onKeyUp(keyCode, event);
  }
Exemple #2
0
 public boolean dispatchTouchEvent(MotionEvent paramMotionEvent) {
   switch (paramMotionEvent.getAction()) {
     case 2:
     default:
     case 0:
     case 1:
     case 3:
     case 4:
   }
   while (true) {
     return super.dispatchTouchEvent(paramMotionEvent);
     if (this.mHighlighEnabled) {
       startDelayTimer();
       continue;
       if (this.mHighlighEnabled) removeDelayTimer();
       if (this.mPressed) {
         this.mPressed = false;
         invalidate();
       } else if (this.mHighlighEnabled) {
         if (this.mUnsetPressedState == null)
           this.mUnsetPressedState = new UnsetPressedState(null);
         this.mPressed = true;
         invalidate();
         this.mPressDelayHandler.postDelayed(
             this.mUnsetPressedState, ViewConfiguration.getPressedStateDuration());
         continue;
         if (this.mHighlighEnabled) removeDelayTimer();
         if (this.mPressed) {
           this.mPressed = false;
           invalidate();
         }
       }
     }
   }
 }
  private void initView(Context context) {
    mPaint = new Paint();
    mPaint.setColor(Color.WHITE);
    Resources resources = context.getResources();

    // get viewConfiguration
    mClickTimeout = ViewConfiguration.getPressedStateDuration() + ViewConfiguration.getTapTimeout();
    mTouchSlop = ViewConfiguration.get(context).getScaledTouchSlop();

    // get Bitmap
    mBottom = BitmapFactory.decodeResource(resources, R.drawable.bottom);
    mBtnPressed = BitmapFactory.decodeResource(resources, R.drawable.btn_pressed);
    mBtnNormal = BitmapFactory.decodeResource(resources, R.drawable.btn_unpressed);
    mFrame = BitmapFactory.decodeResource(resources, R.drawable.frame);
    mMask = BitmapFactory.decodeResource(resources, R.drawable.mask);
    mCurBtnPic = mBtnNormal;

    mBtnWidth = mBtnPressed.getWidth();
    mMaskWidth = mMask.getWidth();
    mMaskHeight = mMask.getHeight();

    mBtnOffPos = mBtnWidth / 2;
    mBtnOnPos = mMaskWidth - mBtnWidth / 2;

    mBtnPos = mChecked ? mBtnOnPos : mBtnOffPos;
    mRealPos = getRealPos(mBtnPos);

    final float density = getResources().getDisplayMetrics().density;
    mVelocity = (int) (VELOCITY * density + 0.5f);
    mExtendOffsetY = (int) (EXTENDED_OFFSET_Y * density + 0.5f);

    mSaveLayerRectF =
        new RectF(0, mExtendOffsetY, mMask.getWidth(), mMask.getHeight() + mExtendOffsetY);
    mXfermode = new PorterDuffXfermode(PorterDuff.Mode.SRC_IN);
  }
  @Override
  public boolean onTouchEvent(@NonNull MotionEvent event) {
    // Stop receiving touch events if we aren't within the bounds, including some slop.
    final int x = (int) event.getX();
    final int y = (int) event.getY();
    if (!pointInCloseBounds(x, y, mTouchSlop)) {
      setClosePressed(false);
      super.onTouchEvent(event);
      return false;
    }

    switch (event.getAction()) {
      case MotionEvent.ACTION_DOWN:
        setClosePressed(true);
        break;
      case MotionEvent.ACTION_CANCEL:
        // Cancelled by a parent
        setClosePressed(false);
        break;
      case MotionEvent.ACTION_UP:
        if (isClosePressed()) {
          // Delay setting the unpressed state so that the button remains pressed
          // at least long enough to respond to the close event.
          if (mUnsetPressedState == null) {
            mUnsetPressedState = new UnsetPressedState();
          }
          postDelayed(mUnsetPressedState, ViewConfiguration.getPressedStateDuration());
          performClose();
        }
        break;
    }
    return true;
  }
  private void init(Context context, AttributeSet attrs) {
    mPaint = new Paint();
    mPaint.setColor(Color.WHITE);
    Resources resources = context.getResources();

    // get attrConfiguration
    TypedArray array = context.obtainStyledAttributes(attrs, R.styleable.SwitchButton);
    int width = (int) array.getDimensionPixelSize(R.styleable.SwitchButton_bmWidth, 0);
    int height = (int) array.getDimensionPixelSize(R.styleable.SwitchButton_bmHeight, 0);
    array.recycle();

    // size width or height
    if (width <= 0 || height <= 0) {
      width = COMMON_WIDTH_IN_PIXEL;
      height = COMMON_HEIGHT_IN_PIXEL;
    } else {
      float scale = (float) COMMON_WIDTH_IN_PIXEL / COMMON_HEIGHT_IN_PIXEL;
      if ((float) width / height > scale) {
        width = (int) (height * scale);
      } else if ((float) width / height < scale) {
        height = (int) (width / scale);
      }
    }

    // get viewConfiguration
    mClickTimeout = ViewConfiguration.getPressedStateDuration() + ViewConfiguration.getTapTimeout();
    mTouchSlop = ViewConfiguration.get(context).getScaledTouchSlop();

    // get Bitmap
    bmBgGreen = BitmapFactory.decodeResource(resources, R.drawable.switch_btn_bg_green);
    bmBgWhite = BitmapFactory.decodeResource(resources, R.drawable.switch_btn_bg_white);
    bmBtnNormal = BitmapFactory.decodeResource(resources, R.drawable.switch_btn_normal);
    bmBtnPressed = BitmapFactory.decodeResource(resources, R.drawable.switch_btn_pressed);

    // size Bitmap
    bmBgGreen = Bitmap.createScaledBitmap(bmBgGreen, width, height, true);
    bmBgWhite = Bitmap.createScaledBitmap(bmBgWhite, width, height, true);
    bmBtnNormal = Bitmap.createScaledBitmap(bmBtnNormal, height, height, true);
    bmBtnPressed = Bitmap.createScaledBitmap(bmBtnPressed, height, height, true);

    bmCurBtnPic = bmBtnNormal; // 初始按钮图片
    bmCurBgPic = mChecked ? bmBgGreen : bmBgWhite; // 初始背景图片
    bgWidth = bmBgGreen.getWidth(); // 背景宽度
    bgHeight = bmBgGreen.getHeight(); // 背景高度
    btnWidth = bmBtnNormal.getWidth(); // 按钮宽度
    offBtnPos = 0; // 关闭时在最左边
    onBtnPos = bgWidth - btnWidth; // 开始时在右边
    curBtnPos = mChecked ? onBtnPos : offBtnPos; // 按钮当前为初始位置

    // get density
    float density = resources.getDisplayMetrics().density;
    mVelocity = (int) (VELOCITY * density + 0.5f); // 动画距离
    mSaveLayerRectF = new RectF(0, 0, bgWidth, bgHeight);
  }
 @Override
 public boolean onTouchEvent(MotionEvent event) {
   boolean superOnTouchEvent = super.onTouchEvent(event);
   if (!isEnabled()) return superOnTouchEvent;
   boolean isEventInBounds = bounds.contains((int) event.getX(), (int) event.getY());
   if (isEventInBounds) {
     previousCoords.set(currentCoords.x, currentCoords.y);
     currentCoords.set((int) event.getX(), (int) event.getY());
   }
   int action = event.getActionMasked();
   switch (action) {
     case MotionEvent.ACTION_UP:
       if (pressed) {
         childView.setPressed(true);
         postDelayed(
             new Runnable() {
               @Override
               public void run() {
                 childView.setPressed(false);
               }
             },
             ViewConfiguration.getPressedStateDuration());
       }
       cancelPressedEvent();
       break;
     case MotionEvent.ACTION_CANCEL:
       //                currentCoords.set();
       childView.onTouchEvent(event);
       if (!pressed) startRipple();
       cancelPressedEvent();
       break;
     case MotionEvent.ACTION_DOWN:
       eventCancelled = false;
       pressEvent = new PressEvent(event);
       pressEvent.run();
       /** *这里注意当这个控件是在ScrollView内部的时候的问题 ** */
       break;
     case MotionEvent.ACTION_MOVE:
       if (isEventInBounds && !eventCancelled) invalidate();
       else if (!isEventInBounds) startRipple();
       if (!isEventInBounds) {
         cancelPressedEvent();
         if (hoverAnimator != null) hoverAnimator.cancel();
         childView.onTouchEvent(event);
         eventCancelled = true;
       }
       break;
   }
   return true;
 }
  private void initView(Context context) {
    mPaint = new Paint();
    mPaint.setColor(Color.WHITE);
    Resources resources = context.getResources();

    // get viewConfiguration
    mClickTimeout = ViewConfiguration.getPressedStateDuration() + ViewConfiguration.getTapTimeout();
    mTouchSlop = ViewConfiguration.get(context).getScaledTouchSlop();

    // get Bitmap
    mBottom = BitmapFactory.decodeResource(resources, R.drawable.kaiguan);
    mBtnPressed = BitmapFactory.decodeResource(resources, R.drawable.yuan);
    mBtnNormal = BitmapFactory.decodeResource(resources, R.drawable.yuan);
    mFrame = BitmapFactory.decodeResource(resources, R.drawable.guan);
    mMask = BitmapFactory.decodeResource(resources, R.drawable.kai);
    mCurBtnPic = mBtnNormal;

    mBtnWidth = mBtnPressed.getWidth();
    mMaskWidth = mMask.getWidth();
    mMaskHeight = mMask.getHeight();

    mBtnOffPos = mBtnWidth / 2;
    mBtnOnPos = mMaskWidth - mBtnWidth / 2;
    // 判断起始位置,如果设定了mChecked为true,起始位置为 mBtnOnPos
    mBtnPos = mChecked ? mBtnOnPos : mBtnOffPos;
    mRealPos = getRealPos(mBtnPos);
    // density 密度
    final float density = getResources().getDisplayMetrics().density; // 方法是获取资源密度(Density)
    mVelocity = (int) (VELOCITY * density + 0.5f);
    mExtendOffsetY = (int) (EXTENDED_OFFSET_Y * density + 0.5f);
    // 创建一个新的矩形与指定的坐标。
    mSaveLayerRectF =
        new RectF(0, mExtendOffsetY, mMask.getWidth(), mMask.getHeight() + mExtendOffsetY);
    mXfermode = new PorterDuffXfermode(PorterDuff.Mode.SRC_IN); // PorterDuff.Mode.SRC_IN
    // :这个属性代表
    // 取两层绘制交集。显示上层。
  }
  @Test
  public void methodsShouldReturnAndroidConstants() {
    Activity context = new Activity();
    ViewConfiguration viewConfiguration = ViewConfiguration.get(context);

    assertEquals(10, ViewConfiguration.getScrollBarSize());
    assertEquals(250, ViewConfiguration.getScrollBarFadeDuration());
    assertEquals(300, ViewConfiguration.getScrollDefaultDelay());
    assertEquals(12, ViewConfiguration.getFadingEdgeLength());
    assertEquals(125, ViewConfiguration.getPressedStateDuration());
    assertEquals(500, ViewConfiguration.getLongPressTimeout());
    assertEquals(115, ViewConfiguration.getTapTimeout());
    assertEquals(500, ViewConfiguration.getJumpTapTimeout());
    assertEquals(300, ViewConfiguration.getDoubleTapTimeout());
    assertEquals(12, ViewConfiguration.getEdgeSlop());
    assertEquals(16, ViewConfiguration.getTouchSlop());
    assertEquals(16, ViewConfiguration.getWindowTouchSlop());
    assertEquals(50, ViewConfiguration.getMinimumFlingVelocity());
    assertEquals(4000, ViewConfiguration.getMaximumFlingVelocity());
    assertEquals(320 * 480 * 4, ViewConfiguration.getMaximumDrawingCacheSize());
    assertEquals(3000, ViewConfiguration.getZoomControlsTimeout());
    assertEquals(500, ViewConfiguration.getGlobalActionKeyTimeout());
    assertEquals(0.015f, ViewConfiguration.getScrollFriction());

    assertEquals(1f, context.getResources().getDisplayMetrics().density);

    assertEquals(10, viewConfiguration.getScaledScrollBarSize());
    assertEquals(12, viewConfiguration.getScaledFadingEdgeLength());
    assertEquals(12, viewConfiguration.getScaledEdgeSlop());
    assertEquals(16, viewConfiguration.getScaledTouchSlop());
    assertEquals(32, viewConfiguration.getScaledPagingTouchSlop());
    assertEquals(100, viewConfiguration.getScaledDoubleTapSlop());
    assertEquals(16, viewConfiguration.getScaledWindowTouchSlop());
    assertEquals(50, viewConfiguration.getScaledMinimumFlingVelocity());
    assertEquals(4000, viewConfiguration.getScaledMaximumFlingVelocity());
  }
  @Override
  public boolean onTouchEvent(MotionEvent ev) {
    final int action = ev.getAction();
    boolean wasHeaderChildBeingPressed = mHeaderChildBeingPressed;
    if (mHeaderChildBeingPressed) {
      final View tempHeader = getHeaderAt(mMotionHeaderPosition);
      final View headerHolder =
          mMotionHeaderPosition == MATCHED_STICKIED_HEADER
              ? tempHeader
              : getChildAt(mMotionHeaderPosition);
      if (action == MotionEvent.ACTION_UP || action == MotionEvent.ACTION_CANCEL) {
        mHeaderChildBeingPressed = false;
      }
      if (tempHeader != null) {
        tempHeader.dispatchTouchEvent(transformEvent(ev, mMotionHeaderPosition));
        tempHeader.invalidate();
        tempHeader.postDelayed(
            new Runnable() {
              public void run() {
                invalidate(
                    0,
                    headerHolder.getTop(),
                    getWidth(),
                    headerHolder.getTop() + headerHolder.getHeight());
              }
            },
            ViewConfiguration.getPressedStateDuration());
        invalidate(
            0, headerHolder.getTop(), getWidth(), headerHolder.getTop() + headerHolder.getHeight());
      }
    }

    switch (action & MotionEvent.ACTION_MASK) {
      case MotionEvent.ACTION_DOWN:
        if (mPendingCheckForTap == null) {
          mPendingCheckForTap = new CheckForHeaderTap();
        }
        postDelayed(mPendingCheckForTap, ViewConfiguration.getTapTimeout());

        final int y = (int) ev.getY();
        mMotionY = y;
        mMotionHeaderPosition = findMotionHeader(y);
        if (mMotionHeaderPosition == NO_MATCHED_HEADER || mScrollState == SCROLL_STATE_FLING) {
          // Don't consume the event and pass it to super because we
          // can't handle it yet.
          break;
        } else {
          View tempHeader = getHeaderAt(mMotionHeaderPosition);
          if (tempHeader != null) {
            if (tempHeader.dispatchTouchEvent(transformEvent(ev, mMotionHeaderPosition))) {
              mHeaderChildBeingPressed = true;
              tempHeader.setPressed(true);
            }
            tempHeader.invalidate();
            if (mMotionHeaderPosition != MATCHED_STICKIED_HEADER) {
              tempHeader = getChildAt(mMotionHeaderPosition);
            }
            invalidate(
                0, tempHeader.getTop(), getWidth(), tempHeader.getTop() + tempHeader.getHeight());
          }
        }
        mTouchMode = TOUCH_MODE_DOWN;
        return true;
      case MotionEvent.ACTION_MOVE:
        if (mMotionHeaderPosition != NO_MATCHED_HEADER
            && Math.abs(ev.getY() - mMotionY) > mTouchSlop) {
          // Detected scroll initiation so cancel touch completion on
          // header.
          mTouchMode = TOUCH_MODE_REST;
          // if (!mHeaderChildBeingPressed) {
          final View header = getHeaderAt(mMotionHeaderPosition);
          if (header != null) {
            header.setPressed(false);
            header.invalidate();
          }
          final Handler handler = getHandler();
          if (handler != null) {
            handler.removeCallbacks(mPendingCheckForLongPress);
          }
          mMotionHeaderPosition = NO_MATCHED_HEADER;
          // }
        }
        break;
      case MotionEvent.ACTION_UP:
        if (mTouchMode == TOUCH_MODE_FINISHED_LONG_PRESS) {
          mTouchMode = TOUCH_MODE_REST;
          return true;
        }
        if (mTouchMode == TOUCH_MODE_REST || mMotionHeaderPosition == NO_MATCHED_HEADER) {
          break;
        }

        final View header = getHeaderAt(mMotionHeaderPosition);
        if (!wasHeaderChildBeingPressed) {
          if (header != null) {
            if (mTouchMode != TOUCH_MODE_DOWN) {
              header.setPressed(false);
            }

            if (mPerformHeaderClick == null) {
              mPerformHeaderClick = new PerformHeaderClick();
            }

            final PerformHeaderClick performHeaderClick = mPerformHeaderClick;
            performHeaderClick.mClickMotionPosition = mMotionHeaderPosition;
            performHeaderClick.rememberWindowAttachCount();

            if (mTouchMode == TOUCH_MODE_DOWN || mTouchMode == TOUCH_MODE_TAP) {
              final Handler handler = getHandler();
              if (handler != null) {
                handler.removeCallbacks(
                    mTouchMode == TOUCH_MODE_DOWN
                        ? mPendingCheckForTap
                        : mPendingCheckForLongPress);
              }

              if (!mDataChanged) {
                /*
                 * Got here so must be a tap. The long press
                 * would have triggered on the callback handler.
                 */
                mTouchMode = TOUCH_MODE_TAP;
                header.setPressed(true);
                setPressed(true);
                if (mTouchModeReset != null) {
                  removeCallbacks(mTouchModeReset);
                }
                mTouchModeReset =
                    new Runnable() {
                      @Override
                      public void run() {
                        mMotionHeaderPosition = NO_MATCHED_HEADER;
                        mTouchModeReset = null;
                        mTouchMode = TOUCH_MODE_REST;
                        header.setPressed(false);
                        setPressed(false);
                        header.invalidate();
                        invalidate(0, header.getTop(), getWidth(), header.getHeight());
                        if (!mDataChanged) {
                          performHeaderClick.run();
                        }
                      }
                    };
                postDelayed(mTouchModeReset, ViewConfiguration.getPressedStateDuration());
              } else {
                mTouchMode = TOUCH_MODE_REST;
              }
            } else if (!mDataChanged) {
              performHeaderClick.run();
            }
          }
        }
        mTouchMode = TOUCH_MODE_REST;
        return true;
    }
    return super.onTouchEvent(ev);
  }
  @Override
  public boolean onTouchEvent(MotionEvent ev) {
    final int action = ev.getAction();
    switch (action & MotionEvent.ACTION_MASK) {
      case MotionEvent.ACTION_DOWN:
        if (mPendingCheckForTap == null) {
          mPendingCheckForTap = new CheckForHeaderTap();
        }
        postDelayed(mPendingCheckForTap, ViewConfiguration.getTapTimeout());

        final int y = (int) ev.getY();
        mMotionY = y;
        mMotionHeaderPosition = findMotionHeader(y);
        if (mMotionHeaderPosition == NO_MATCHED_HEADER || mScrollState == SCROLL_STATE_FLING) {
          // Don't consume the event and pass it to super because we
          // can't handle it yet.
          break;
        }
        mTouchMode = TOUCH_MODE_DOWN;
        return true;
      case MotionEvent.ACTION_MOVE:
        if (mMotionHeaderPosition != NO_MATCHED_HEADER
            && Math.abs(ev.getY() - mMotionY) > mTouchSlop) {
          // Detected scroll initiation so cancel touch completion on
          // header.
          mTouchMode = TOUCH_MODE_REST;
          final View header = getHeaderAt(mMotionHeaderPosition);
          if (header != null) {
            header.setPressed(false);
          }
          final Handler handler = getHandler();
          if (handler != null) {
            handler.removeCallbacks(mPendingCheckForLongPress);
          }
          mMotionHeaderPosition = NO_MATCHED_HEADER;
        }
        break;
      case MotionEvent.ACTION_UP:
        if (mTouchMode == TOUCH_MODE_FINISHED_LONG_PRESS) {
          return true;
        }
        if (mTouchMode == TOUCH_MODE_REST || mMotionHeaderPosition == NO_MATCHED_HEADER) {
          break;
        }

        final View header = getHeaderAt(mMotionHeaderPosition);
        if (header != null && !header.hasFocusable()) {
          if (mTouchMode != TOUCH_MODE_DOWN) {
            header.setPressed(false);
          }

          if (mPerformHeaderClick == null) {
            mPerformHeaderClick = new PerformHeaderClick();
          }

          final PerformHeaderClick performHeaderClick = mPerformHeaderClick;
          performHeaderClick.mClickMotionPosition = mMotionHeaderPosition;
          performHeaderClick.rememberWindowAttachCount();

          if (mTouchMode != TOUCH_MODE_DOWN || mTouchMode != TOUCH_MODE_TAP) {
            final Handler handler = getHandler();
            if (handler != null) {
              handler.removeCallbacks(
                  mTouchMode == TOUCH_MODE_DOWN ? mPendingCheckForTap : mPendingCheckForLongPress);
            }

            if (!mDataChanged) {
              // Got here so must be a tap. The long press would
              // have trigger on the callback handler. Probably.
              mTouchMode = TOUCH_MODE_TAP;
              header.setPressed(true);
              setPressed(true);
              if (mTouchModeReset != null) {
                removeCallbacks(mTouchModeReset);
              }
              mTouchModeReset =
                  new Runnable() {
                    @Override
                    public void run() {
                      mTouchMode = TOUCH_MODE_REST;
                      header.setPressed(false);
                      setPressed(false);
                      if (!mDataChanged) {
                        performHeaderClick.run();
                      }
                    }
                  };
              postDelayed(mTouchModeReset, ViewConfiguration.getPressedStateDuration());
            } else {
              mTouchMode = TOUCH_MODE_REST;
            }
          } else if (!mDataChanged) {
            performHeaderClick.run();
          }
        }
        mTouchMode = TOUCH_MODE_REST;
        return true;
    }
    return super.onTouchEvent(ev);
  }
  @Override
  public boolean onTouchEvent(MotionEvent event) {
    boolean superOnTouchEvent = super.onTouchEvent(event);

    if (!isEnabled() || !childView.isEnabled()) return superOnTouchEvent;

    boolean isEventInBounds = bounds.contains((int) event.getX(), (int) event.getY());

    if (isEventInBounds) {
      previousCoords.set(currentCoords.x, currentCoords.y);
      currentCoords.set((int) event.getX(), (int) event.getY());
    }

    boolean gestureResult = gestureDetector.onTouchEvent(event);
    if (gestureResult || mHasPerformedLongPress) {
      return true;
    } else {
      int action = event.getActionMasked();
      switch (action) {
        case MotionEvent.ACTION_UP:
          pendingClickEvent = new PerformClickEvent();

          if (prePressed) {
            childView.setPressed(true);
            postDelayed(
                new Runnable() {
                  @Override
                  public void run() {
                    childView.setPressed(false);
                  }
                },
                ViewConfiguration.getPressedStateDuration());
          }

          if (isEventInBounds) {
            startRipple(pendingClickEvent);
          } else if (!rippleHover) {
            setRadius(0);
          }
          if (!rippleDelayClick && isEventInBounds) {
            pendingClickEvent.run();
          }
          cancelPressedEvent();
          break;
        case MotionEvent.ACTION_DOWN:
          setPositionInAdapter();
          eventCancelled = false;
          pendingPressEvent = new PressedEvent(event);
          if (isInScrollingContainer()) {
            cancelPressedEvent();
            prePressed = true;
            postDelayed(pendingPressEvent, ViewConfiguration.getTapTimeout());
          } else {
            pendingPressEvent.run();
          }
          break;
        case MotionEvent.ACTION_CANCEL:
          if (rippleInAdapter) {
            // dont use current coords in adapter since they tend to jump drastically on scroll
            currentCoords.set(previousCoords.x, previousCoords.y);
            previousCoords = new Point();
          }
          childView.onTouchEvent(event);
          if (rippleHover) {
            if (!prePressed) {
              startRipple(null);
            }
          } else {
            childView.setPressed(false);
          }
          cancelPressedEvent();
          break;
        case MotionEvent.ACTION_MOVE:
          if (rippleHover) {
            if (isEventInBounds && !eventCancelled) {
              invalidate();
            } else if (!isEventInBounds) {
              startRipple(null);
            }
          }

          if (!isEventInBounds) {
            cancelPressedEvent();
            if (hoverAnimator != null) {
              hoverAnimator.cancel();
            }
            childView.onTouchEvent(event);
            eventCancelled = true;
          }
          break;
      }
      return true;
    }
  }
/**
 * Perform asynchronous dispatch of input events in a {@link WebView}.
 *
 * <p>This dispatcher is shared by the UI thread ({@link WebViewClassic}) and web kit thread ({@link
 * WebViewCore}). The UI thread enqueues events for processing, waits for the web kit thread to
 * handle them, and then performs additional processing depending on the outcome.
 *
 * <p>How it works:
 *
 * <p>1. The web view thread receives an input event from the input system on the UI thread in its
 * {@link WebViewClassic#onTouchEvent} handler. It sends the input event to the dispatcher, then
 * immediately returns true to the input system to indicate that it will handle the event.
 *
 * <p>2. The web kit thread is notified that an event has been enqueued. Meanwhile additional events
 * may be enqueued from the UI thread. In some cases, the dispatcher may decide to coalesce motion
 * events into larger batches or to cancel events that have been sitting in the queue for too long.
 *
 * <p>3. The web kit thread wakes up and handles all input events that are waiting for it. After
 * processing each input event, it informs the dispatcher whether the web application has decided to
 * handle the event itself and to prevent default event handling.
 *
 * <p>4. If web kit indicates that it wants to prevent default event handling, then web kit consumes
 * the remainder of the gesture and web view receives a cancel event if needed. Otherwise, the web
 * view handles the gesture on the UI thread normally.
 *
 * <p>5. If the web kit thread takes too long to handle an input event, then it loses the right to
 * handle it. The dispatcher synthesizes a cancellation event for web kit and then tells the web
 * view on the UI thread to handle the event that timed out along with the rest of the gesture.
 *
 * <p>One thing to keep in mind about the dispatcher is that what goes into the dispatcher is not
 * necessarily what the web kit or UI thread will see. As mentioned above, the dispatcher may tweak
 * the input event stream to improve responsiveness. Both web view and web kit are guaranteed to
 * perceive a consistent stream of input events but they might not always see the same events
 * (especially if one decides to prevent the other from handling a particular gesture).
 *
 * <p>This implementation very deliberately does not refer to the {@link WebViewClassic} or {@link
 * WebViewCore} classes, preferring to communicate with them only via interfaces to avoid
 * unintentional coupling to their implementation details.
 *
 * <p>Currently, the input dispatcher only handles pointer events (includes touch, hover and scroll
 * events). In principle, it could be extended to handle trackball and key events if needed.
 *
 * @hide
 */
final class WebViewInputDispatcher {
  private static final String TAG = "WebViewInputDispatcher";
  private static final boolean DEBUG = false;
  // This enables batching of MotionEvents. It will combine multiple MotionEvents
  // together into a single MotionEvent if more events come in while we are
  // still waiting on the processing of a previous event.
  // If this is set to false, we will instead opt to drop ACTION_MOVE
  // events we cannot keep up with.
  // TODO: If batching proves to be working well, remove this
  private static final boolean ENABLE_EVENT_BATCHING = true;

  private final Object mLock = new Object();

  // Pool of queued input events.  (guarded by mLock)
  private static final int MAX_DISPATCH_EVENT_POOL_SIZE = 10;
  private DispatchEvent mDispatchEventPool;
  private int mDispatchEventPoolSize;

  // Posted state, tracks events posted to the dispatcher.  (guarded by mLock)
  private final TouchStream mPostTouchStream = new TouchStream();
  private boolean mPostSendTouchEventsToWebKit;
  private boolean mPostDoNotSendTouchEventsToWebKitUntilNextGesture;
  private boolean mPostLongPressScheduled;
  private boolean mPostClickScheduled;
  private boolean mPostShowTapHighlightScheduled;
  private boolean mPostHideTapHighlightScheduled;
  private int mPostLastWebKitXOffset;
  private int mPostLastWebKitYOffset;
  private float mPostLastWebKitScale;

  // State for event tracking (click, longpress, double tap, etc..)
  private boolean mIsDoubleTapCandidate;
  private boolean mIsTapCandidate;
  private float mInitialDownX;
  private float mInitialDownY;
  private float mTouchSlopSquared;
  private float mDoubleTapSlopSquared;

  // Web kit state, tracks events observed by web kit.  (guarded by mLock)
  private final DispatchEventQueue mWebKitDispatchEventQueue = new DispatchEventQueue();
  private final TouchStream mWebKitTouchStream = new TouchStream();
  private final WebKitCallbacks mWebKitCallbacks;
  private final WebKitHandler mWebKitHandler;
  private boolean mWebKitDispatchScheduled;
  private boolean mWebKitTimeoutScheduled;
  private long mWebKitTimeoutTime;
  /// M: Web kit state, tracks events prevent by web kit.
  private final PreventTouchStream mWebKitPreventTouchStream = new PreventTouchStream();

  // UI state, tracks events observed by the UI.  (guarded by mLock)
  private final DispatchEventQueue mUiDispatchEventQueue = new DispatchEventQueue();
  private final TouchStream mUiTouchStream = new TouchStream();
  private final UiCallbacks mUiCallbacks;
  private final UiHandler mUiHandler;
  private boolean mUiDispatchScheduled;

  // Give up on web kit handling of input events when this timeout expires.
  private static final long WEBKIT_TIMEOUT_MILLIS = 200;
  private static final int TAP_TIMEOUT = ViewConfiguration.getTapTimeout();
  private static final int LONG_PRESS_TIMEOUT =
      ViewConfiguration.getLongPressTimeout() + TAP_TIMEOUT;
  private static final int DOUBLE_TAP_TIMEOUT = ViewConfiguration.getDoubleTapTimeout();
  private static final int PRESSED_STATE_DURATION = ViewConfiguration.getPressedStateDuration();

  /**
   * Event type: Indicates a touch event type.
   *
   * <p>This event is delivered together with a {@link MotionEvent} with one of the following
   * actions: {@link MotionEvent#ACTION_DOWN}, {@link MotionEvent#ACTION_MOVE}, {@link
   * MotionEvent#ACTION_UP}, {@link MotionEvent#ACTION_POINTER_DOWN}, {@link
   * MotionEvent#ACTION_POINTER_UP}, {@link MotionEvent#ACTION_CANCEL}.
   */
  public static final int EVENT_TYPE_TOUCH = 0;

  /**
   * Event type: Indicates a hover event type.
   *
   * <p>This event is delivered together with a {@link MotionEvent} with one of the following
   * actions: {@link MotionEvent#ACTION_HOVER_ENTER}, {@link MotionEvent#ACTION_HOVER_MOVE}, {@link
   * MotionEvent#ACTION_HOVER_MOVE}.
   */
  public static final int EVENT_TYPE_HOVER = 1;

  /**
   * Event type: Indicates a scroll event type.
   *
   * <p>This event is delivered together with a {@link MotionEvent} with action {@link
   * MotionEvent#ACTION_SCROLL}.
   */
  public static final int EVENT_TYPE_SCROLL = 2;

  /**
   * Event type: Indicates a long-press event type.
   *
   * <p>This event is delivered in the middle of a sequence of {@link #EVENT_TYPE_TOUCH} events. It
   * includes a {@link MotionEvent} with action {@link MotionEvent#ACTION_MOVE} that indicates the
   * current touch coordinates of the long-press.
   *
   * <p>This event is sent when the current touch gesture has been held longer than the long-press
   * interval.
   */
  public static final int EVENT_TYPE_LONG_PRESS = 3;

  /**
   * Event type: Indicates a click event type.
   *
   * <p>This event is delivered after a sequence of {@link #EVENT_TYPE_TOUCH} events that comprise a
   * complete gesture ending with {@link MotionEvent#ACTION_UP}. It includes a {@link MotionEvent}
   * with action {@link MotionEvent#ACTION_UP} that indicates the location of the click.
   *
   * <p>This event is sent shortly after the end of a touch after the double-tap interval has
   * expired to indicate a click.
   */
  public static final int EVENT_TYPE_CLICK = 4;

  /**
   * Event type: Indicates a double-tap event type.
   *
   * <p>This event is delivered after a sequence of {@link #EVENT_TYPE_TOUCH} events that comprise a
   * complete gesture ending with {@link MotionEvent#ACTION_UP}. It includes a {@link MotionEvent}
   * with action {@link MotionEvent#ACTION_UP} that indicates the location of the double-tap.
   *
   * <p>This event is sent immediately after a sequence of two touches separated in time by no more
   * than the double-tap interval and separated in space by no more than the double-tap slop.
   */
  public static final int EVENT_TYPE_DOUBLE_TAP = 5;

  /** Event type: Indicates that a hit test should be performed */
  public static final int EVENT_TYPE_HIT_TEST = 6;

  /** Flag: This event is private to this queue. Do not forward it. */
  public static final int FLAG_PRIVATE = 1 << 0;

  /**
   * Flag: This event is currently being processed by web kit. If a timeout occurs, make a copy of
   * it before forwarding the event to another queue.
   */
  public static final int FLAG_WEBKIT_IN_PROGRESS = 1 << 1;

  /** Flag: A timeout occurred while waiting for web kit to process this input event. */
  public static final int FLAG_WEBKIT_TIMEOUT = 1 << 2;

  /**
   * Flag: Indicates that the event was transformed for delivery to web kit. The event must be
   * transformed back before being delivered to the UI.
   */
  public static final int FLAG_WEBKIT_TRANSFORMED_EVENT = 1 << 3;

  public WebViewInputDispatcher(UiCallbacks uiCallbacks, WebKitCallbacks webKitCallbacks) {
    this.mUiCallbacks = uiCallbacks;
    mUiHandler = new UiHandler(uiCallbacks.getUiLooper());

    this.mWebKitCallbacks = webKitCallbacks;
    mWebKitHandler = new WebKitHandler(webKitCallbacks.getWebKitLooper());

    ViewConfiguration config = ViewConfiguration.get(mUiCallbacks.getContext());
    mDoubleTapSlopSquared = config.getScaledDoubleTapSlop();
    mDoubleTapSlopSquared = (mDoubleTapSlopSquared * mDoubleTapSlopSquared);
    mTouchSlopSquared = config.getScaledTouchSlop();
    mTouchSlopSquared = (mTouchSlopSquared * mTouchSlopSquared);
  }

  /**
   * Sets whether web kit wants to receive touch events.
   *
   * @param enable True to enable dispatching of touch events to web kit, otherwise web kit will be
   *     skipped.
   */
  public void setWebKitWantsTouchEvents(boolean enable) {
    if (DEBUG) {
      Log.d(TAG, "webkitWantsTouchEvents: " + enable);
    }
    synchronized (mLock) {
      if (mPostSendTouchEventsToWebKit != enable) {
        if (!enable) {
          enqueueWebKitCancelTouchEventIfNeededLocked();
        }
        mPostSendTouchEventsToWebKit = enable;
      }
    }
  }

  /**
   * Posts a pointer event to the dispatch queue.
   *
   * @param event The event to post.
   * @param webKitXOffset X offset to apply to events before dispatching them to web kit.
   * @param webKitYOffset Y offset to apply to events before dispatching them to web kit.
   * @param webKitScale The scale factor to apply to translated events before dispatching them to
   *     web kit.
   * @return True if the dispatcher will handle the event, false if the event is unsupported.
   */
  public boolean postPointerEvent(
      MotionEvent event, int webKitXOffset, int webKitYOffset, float webKitScale) {
    if (event == null) {
      throw new IllegalArgumentException("event cannot be null");
    }

    if (DEBUG) {
      Log.d(TAG, "postPointerEvent: " + event);
    }

    final int action = event.getActionMasked();
    final int eventType;
    switch (action) {
      case MotionEvent.ACTION_DOWN:
      case MotionEvent.ACTION_MOVE:
      case MotionEvent.ACTION_UP:
      case MotionEvent.ACTION_POINTER_DOWN:
      case MotionEvent.ACTION_POINTER_UP:
      case MotionEvent.ACTION_CANCEL:
        eventType = EVENT_TYPE_TOUCH;
        break;
      case MotionEvent.ACTION_SCROLL:
        eventType = EVENT_TYPE_SCROLL;
        break;
      case MotionEvent.ACTION_HOVER_ENTER:
      case MotionEvent.ACTION_HOVER_MOVE:
      case MotionEvent.ACTION_HOVER_EXIT:
        eventType = EVENT_TYPE_HOVER;
        break;
      default:
        return false; // currently unsupported event type
    }

    synchronized (mLock) {
      // Ensure that the event is consistent and should be delivered.
      MotionEvent eventToEnqueue = event;
      if (eventType == EVENT_TYPE_TOUCH) {
        eventToEnqueue = mPostTouchStream.update(event);
        if (eventToEnqueue == null) {
          if (DEBUG) {
            Log.d(TAG, "postPointerEvent: dropped event " + event);
          }
          unscheduleLongPressLocked();
          unscheduleClickLocked();
          hideTapCandidateLocked();
          return false;
        }

        if (action == MotionEvent.ACTION_DOWN && mPostSendTouchEventsToWebKit) {
          if (mUiCallbacks.shouldInterceptTouchEvent(eventToEnqueue)) {
            mPostDoNotSendTouchEventsToWebKitUntilNextGesture = true;
          } else if (mPostDoNotSendTouchEventsToWebKitUntilNextGesture) {
            // Recover from a previous web kit timeout.
            mPostDoNotSendTouchEventsToWebKitUntilNextGesture = false;
          }
        }
      }

      // Copy the event because we need to retain ownership.
      if (eventToEnqueue == event) {
        eventToEnqueue = event.copy();
      }

      DispatchEvent d =
          obtainDispatchEventLocked(
              eventToEnqueue, eventType, 0, webKitXOffset, webKitYOffset, webKitScale);
      updateStateTrackersLocked(d, event);
      enqueueEventLocked(d);
    }
    return true;
  }

  private void scheduleLongPressLocked() {
    unscheduleLongPressLocked();
    mPostLongPressScheduled = true;
    mUiHandler.sendEmptyMessageDelayed(UiHandler.MSG_LONG_PRESS, LONG_PRESS_TIMEOUT);
  }

  private void unscheduleLongPressLocked() {
    if (mPostLongPressScheduled) {
      mPostLongPressScheduled = false;
      mUiHandler.removeMessages(UiHandler.MSG_LONG_PRESS);
    }
  }

  private void postLongPress() {
    synchronized (mLock) {
      if (!mPostLongPressScheduled) {
        return;
      }
      mPostLongPressScheduled = false;

      MotionEvent event = mPostTouchStream.getLastEvent();
      if (event == null) {
        return;
      }

      switch (event.getActionMasked()) {
        case MotionEvent.ACTION_DOWN:
        case MotionEvent.ACTION_MOVE:
        case MotionEvent.ACTION_POINTER_DOWN:
        case MotionEvent.ACTION_POINTER_UP:
          break;
        default:
          return;
      }

      MotionEvent eventToEnqueue = MotionEvent.obtainNoHistory(event);
      eventToEnqueue.setAction(MotionEvent.ACTION_MOVE);
      DispatchEvent d =
          obtainDispatchEventLocked(
              eventToEnqueue,
              EVENT_TYPE_LONG_PRESS,
              0,
              mPostLastWebKitXOffset,
              mPostLastWebKitYOffset,
              mPostLastWebKitScale);
      enqueueEventLocked(d);
    }
  }

  private void hideTapCandidateLocked() {
    unscheduleHideTapHighlightLocked();
    unscheduleShowTapHighlightLocked();
    mUiCallbacks.showTapHighlight(false);
  }

  private void showTapCandidateLocked() {
    unscheduleHideTapHighlightLocked();
    unscheduleShowTapHighlightLocked();
    mUiCallbacks.showTapHighlight(true);
  }

  private void scheduleShowTapHighlightLocked() {
    unscheduleShowTapHighlightLocked();
    mPostShowTapHighlightScheduled = true;
    mUiHandler.sendEmptyMessageDelayed(UiHandler.MSG_SHOW_TAP_HIGHLIGHT, TAP_TIMEOUT);
  }

  private void unscheduleShowTapHighlightLocked() {
    if (mPostShowTapHighlightScheduled) {
      mPostShowTapHighlightScheduled = false;
      mUiHandler.removeMessages(UiHandler.MSG_SHOW_TAP_HIGHLIGHT);
    }
  }

  private void scheduleHideTapHighlightLocked() {
    unscheduleHideTapHighlightLocked();
    mPostHideTapHighlightScheduled = true;
    mUiHandler.sendEmptyMessageDelayed(UiHandler.MSG_HIDE_TAP_HIGHLIGHT, PRESSED_STATE_DURATION);
  }

  private void unscheduleHideTapHighlightLocked() {
    if (mPostHideTapHighlightScheduled) {
      mPostHideTapHighlightScheduled = false;
      mUiHandler.removeMessages(UiHandler.MSG_HIDE_TAP_HIGHLIGHT);
    }
  }

  private void postShowTapHighlight(boolean show) {
    synchronized (mLock) {
      if (show) {
        if (!mPostShowTapHighlightScheduled) {
          return;
        }
        mPostShowTapHighlightScheduled = false;
      } else {
        if (!mPostHideTapHighlightScheduled) {
          return;
        }
        mPostHideTapHighlightScheduled = false;
      }
      mUiCallbacks.showTapHighlight(show);
    }
  }

  private void scheduleClickLocked() {
    unscheduleClickLocked();
    mPostClickScheduled = true;
    mUiHandler.sendEmptyMessageDelayed(UiHandler.MSG_CLICK, DOUBLE_TAP_TIMEOUT);
  }

  private void unscheduleClickLocked() {
    if (mPostClickScheduled) {
      mPostClickScheduled = false;
      mUiHandler.removeMessages(UiHandler.MSG_CLICK);
    }
  }

  private void postClick() {
    synchronized (mLock) {
      if (!mPostClickScheduled) {
        return;
      }
      mPostClickScheduled = false;

      MotionEvent event = mPostTouchStream.getLastEvent();
      if (event == null || event.getAction() != MotionEvent.ACTION_UP) {
        return;
      }

      showTapCandidateLocked();
      MotionEvent eventToEnqueue = MotionEvent.obtainNoHistory(event);
      DispatchEvent d =
          obtainDispatchEventLocked(
              eventToEnqueue,
              EVENT_TYPE_CLICK,
              0,
              mPostLastWebKitXOffset,
              mPostLastWebKitYOffset,
              mPostLastWebKitScale);
      enqueueEventLocked(d);
    }
  }

  private void checkForDoubleTapOnDownLocked(MotionEvent event) {
    mIsDoubleTapCandidate = false;
    if (!mPostClickScheduled) {
      return;
    }
    int deltaX = (int) mInitialDownX - (int) event.getX();
    int deltaY = (int) mInitialDownY - (int) event.getY();
    if ((deltaX * deltaX + deltaY * deltaY) < mDoubleTapSlopSquared) {
      unscheduleClickLocked();
      mIsDoubleTapCandidate = true;
    }
  }

  private boolean isClickCandidateLocked(MotionEvent event) {
    if (event == null || event.getActionMasked() != MotionEvent.ACTION_UP || !mIsTapCandidate) {
      return false;
    }
    long downDuration = event.getEventTime() - event.getDownTime();
    return downDuration < LONG_PRESS_TIMEOUT;
  }

  private void enqueueDoubleTapLocked(MotionEvent event) {
    MotionEvent eventToEnqueue = MotionEvent.obtainNoHistory(event);
    DispatchEvent d =
        obtainDispatchEventLocked(
            eventToEnqueue,
            EVENT_TYPE_DOUBLE_TAP,
            0,
            mPostLastWebKitXOffset,
            mPostLastWebKitYOffset,
            mPostLastWebKitScale);
    enqueueEventLocked(d);
  }

  private void enqueueHitTestLocked(MotionEvent event) {
    mUiCallbacks.clearPreviousHitTest();
    MotionEvent eventToEnqueue = MotionEvent.obtainNoHistory(event);
    DispatchEvent d =
        obtainDispatchEventLocked(
            eventToEnqueue,
            EVENT_TYPE_HIT_TEST,
            0,
            mPostLastWebKitXOffset,
            mPostLastWebKitYOffset,
            mPostLastWebKitScale);
    enqueueEventLocked(d);
  }

  private void checkForSlopLocked(MotionEvent event) {
    if (!mIsTapCandidate) {
      return;
    }
    int deltaX = (int) mInitialDownX - (int) event.getX();
    int deltaY = (int) mInitialDownY - (int) event.getY();
    if ((deltaX * deltaX + deltaY * deltaY) > mTouchSlopSquared) {
      unscheduleLongPressLocked();
      mIsTapCandidate = false;
      hideTapCandidateLocked();
    }
  }

  private void updateStateTrackersLocked(DispatchEvent d, MotionEvent event) {
    mPostLastWebKitXOffset = d.mWebKitXOffset;
    mPostLastWebKitYOffset = d.mWebKitYOffset;
    mPostLastWebKitScale = d.mWebKitScale;
    int action = event != null ? event.getAction() : MotionEvent.ACTION_CANCEL;
    if (d.mEventType != EVENT_TYPE_TOUCH) {
      return;
    }

    if (action == MotionEvent.ACTION_CANCEL || event.getPointerCount() > 1) {
      unscheduleLongPressLocked();
      unscheduleClickLocked();
      hideTapCandidateLocked();
      mIsDoubleTapCandidate = false;
      mIsTapCandidate = false;
      hideTapCandidateLocked();
    } else if (action == MotionEvent.ACTION_DOWN) {
      checkForDoubleTapOnDownLocked(event);
      scheduleLongPressLocked();
      mIsTapCandidate = true;
      mInitialDownX = event.getX();
      mInitialDownY = event.getY();
      enqueueHitTestLocked(event);
      if (mIsDoubleTapCandidate) {
        hideTapCandidateLocked();
      } else {
        scheduleShowTapHighlightLocked();
      }
    } else if (action == MotionEvent.ACTION_UP) {
      unscheduleLongPressLocked();
      if (isClickCandidateLocked(event)) {
        if (mIsDoubleTapCandidate) {
          hideTapCandidateLocked();
          enqueueDoubleTapLocked(event);
        } else {
          scheduleClickLocked();
        }
      } else {
        hideTapCandidateLocked();
      }
    } else if (action == MotionEvent.ACTION_MOVE) {
      checkForSlopLocked(event);
    }
  }

  /**
   * Dispatches pending web kit events. Must only be called from the web kit thread.
   *
   * <p>This method may be used to flush the queue of pending input events immediately. This method
   * may help to reduce input dispatch latency if called before certain expensive operations such as
   * drawing.
   */
  public void dispatchWebKitEvents() {
    dispatchWebKitEvents(false);
  }

  private void dispatchWebKitEvents(boolean calledFromHandler) {
    for (; ; ) {
      // Get the next event, but leave it in the queue so we can move it to the UI
      // queue if a timeout occurs.
      DispatchEvent d;
      MotionEvent event;
      final int eventType;
      int flags;
      synchronized (mLock) {
        if (!ENABLE_EVENT_BATCHING) {
          drainStaleWebKitEventsLocked();
        }
        d = mWebKitDispatchEventQueue.mHead;
        if (d == null) {
          if (mWebKitDispatchScheduled) {
            mWebKitDispatchScheduled = false;
            if (!calledFromHandler) {
              mWebKitHandler.removeMessages(WebKitHandler.MSG_DISPATCH_WEBKIT_EVENTS);
            }
          }
          return;
        }

        event = d.mEvent;
        if (event != null) {
          event.offsetLocation(d.mWebKitXOffset, d.mWebKitYOffset);
          event.scale(d.mWebKitScale);
          d.mFlags |= FLAG_WEBKIT_TRANSFORMED_EVENT;
        }

        eventType = d.mEventType;
        if (eventType == EVENT_TYPE_TOUCH) {
          event = mWebKitTouchStream.update(event);
          if (DEBUG && event == null && d.mEvent != null) {
            Log.d(TAG, "dispatchWebKitEvents: dropped event " + d.mEvent);
          }
        }

        d.mFlags |= FLAG_WEBKIT_IN_PROGRESS;
        flags = d.mFlags;
      }

      // Handle the event.
      final boolean preventDefault;
      if (event == null) {
        preventDefault = false;
      } else {
        preventDefault = dispatchWebKitEvent(event, eventType, flags);
      }

      synchronized (mLock) {
        /// M: update last event prevent status. @ {
        boolean lastPreventDefault = false;
        if (d.mEventType == EVENT_TYPE_TOUCH) {
          lastPreventDefault = mWebKitPreventTouchStream.update(event, preventDefault);
        }
        /// @ }
        flags = d.mFlags;
        d.mFlags = flags & ~FLAG_WEBKIT_IN_PROGRESS;
        boolean recycleEvent = event != d.mEvent;

        if ((flags & FLAG_WEBKIT_TIMEOUT) != 0) {
          // A timeout occurred!
          recycleDispatchEventLocked(d);
        } else {
          // Web kit finished in a timely manner.  Dequeue the event.
          assert mWebKitDispatchEventQueue.mHead == d;
          mWebKitDispatchEventQueue.dequeue();

          updateWebKitTimeoutLocked();

          if ((flags & FLAG_PRIVATE) != 0) {
            // Event was intended for web kit only.  All done.
            recycleDispatchEventLocked(d);
          } else if (preventDefault) {
            // Web kit has decided to consume the event!
            if (d.mEventType == EVENT_TYPE_TOUCH) {
              /// M: Consider two consistent events is preventDefault. @ {
              if (lastPreventDefault) {
                Log.d(TAG, "Webkit prevent current and last event, cancel ui event");
                enqueueUiCancelTouchEventIfNeededLocked();
              } else {
                Log.d(TAG, "Webkit prevent current but not last event, enqueue ui event");
                /// Only one event is preventDefault, Ui also handle this touch event.
                enqueueUiEventUnbatchedLocked(d);
              }
              unscheduleLongPressLocked();
              /// @ }
            }
          } else {
            // Web kit is being friendly.  Pass the event to the UI.
            enqueueUiEventUnbatchedLocked(d);
          }
        }

        if (event != null && recycleEvent) {
          event.recycle();
        }

        if (eventType == EVENT_TYPE_CLICK) {
          scheduleHideTapHighlightLocked();
        }
      }
    }
  }

  // Runs on web kit thread.
  private boolean dispatchWebKitEvent(MotionEvent event, int eventType, int flags) {
    if (DEBUG) {
      Log.d(
          TAG,
          "dispatchWebKitEvent: event=" + event + ", eventType=" + eventType + ", flags=" + flags);
    }
    boolean preventDefault = mWebKitCallbacks.dispatchWebKitEvent(this, event, eventType, flags);
    if (DEBUG) {
      Log.d(TAG, "dispatchWebKitEvent: preventDefault=" + preventDefault);
    }
    return preventDefault;
  }

  private boolean isMoveEventLocked(DispatchEvent d) {
    return d.mEvent != null && d.mEvent.getActionMasked() == MotionEvent.ACTION_MOVE;
  }

  private void drainStaleWebKitEventsLocked() {
    DispatchEvent d = mWebKitDispatchEventQueue.mHead;
    while (d != null && d.mNext != null && isMoveEventLocked(d) && isMoveEventLocked(d.mNext)) {
      DispatchEvent next = d.mNext;
      skipWebKitEventLocked(d);
      d = next;
    }
    mWebKitDispatchEventQueue.mHead = d;
  }

  // Called by WebKit when it doesn't care about the rest of the touch stream
  public void skipWebkitForRemainingTouchStream() {
    // Just treat this like a timeout
    handleWebKitTimeout();
  }

  // Runs on UI thread in response to the web kit thread appearing to be unresponsive.
  private void handleWebKitTimeout() {
    synchronized (mLock) {
      if (!mWebKitTimeoutScheduled) {
        return;
      }
      mWebKitTimeoutScheduled = false;

      if (DEBUG) {
        Log.d(TAG, "handleWebKitTimeout: timeout occurred!");
      }

      // Drain the web kit event queue.
      DispatchEvent d = mWebKitDispatchEventQueue.dequeueList();

      // If web kit was processing an event (must be at the head of the list because
      // it can only do one at a time), then clone it or ignore it.
      if ((d.mFlags & FLAG_WEBKIT_IN_PROGRESS) != 0) {
        d.mFlags |= FLAG_WEBKIT_TIMEOUT;
        if ((d.mFlags & FLAG_PRIVATE) != 0) {
          d = d.mNext; // the event is private to web kit, ignore it
        } else {
          d = copyDispatchEventLocked(d);
          d.mFlags &= ~FLAG_WEBKIT_IN_PROGRESS;
        }
      }

      // Enqueue all non-private events for handling by the UI thread.
      while (d != null) {
        DispatchEvent next = d.mNext;
        skipWebKitEventLocked(d);
        d = next;
      }

      // Tell web kit to cancel all pending touches.
      // This also prevents us from sending web kit any more touches until the
      // next gesture begins.  (As required to ensure touch event stream consistency.)
      enqueueWebKitCancelTouchEventIfNeededLocked();
    }
  }

  private void skipWebKitEventLocked(DispatchEvent d) {
    d.mNext = null;
    if ((d.mFlags & FLAG_PRIVATE) != 0) {
      recycleDispatchEventLocked(d);
    } else {
      d.mFlags |= FLAG_WEBKIT_TIMEOUT;
      enqueueUiEventUnbatchedLocked(d);
    }
  }

  /**
   * Dispatches pending UI events. Must only be called from the UI thread.
   *
   * <p>This method may be used to flush the queue of pending input events immediately. This method
   * may help to reduce input dispatch latency if called before certain expensive operations such as
   * drawing.
   */
  public void dispatchUiEvents() {
    dispatchUiEvents(false);
  }

  private void dispatchUiEvents(boolean calledFromHandler) {
    for (; ; ) {
      MotionEvent event;
      final int eventType;
      final int flags;
      synchronized (mLock) {
        DispatchEvent d = mUiDispatchEventQueue.dequeue();
        if (d == null) {
          if (mUiDispatchScheduled) {
            mUiDispatchScheduled = false;
            if (!calledFromHandler) {
              mUiHandler.removeMessages(UiHandler.MSG_DISPATCH_UI_EVENTS);
            }
          }
          return;
        }

        event = d.mEvent;
        if (event != null && (d.mFlags & FLAG_WEBKIT_TRANSFORMED_EVENT) != 0) {
          event.scale(1.0f / d.mWebKitScale);
          event.offsetLocation(-d.mWebKitXOffset, -d.mWebKitYOffset);
          d.mFlags &= ~FLAG_WEBKIT_TRANSFORMED_EVENT;
        }

        eventType = d.mEventType;
        if (eventType == EVENT_TYPE_TOUCH) {
          event = mUiTouchStream.update(event);
          if (DEBUG && event == null && d.mEvent != null) {
            Log.d(TAG, "dispatchUiEvents: dropped event " + d.mEvent);
          }
        }

        flags = d.mFlags;

        if (event == d.mEvent) {
          d.mEvent = null; // retain ownership of event, don't recycle it yet
        }
        recycleDispatchEventLocked(d);

        if (eventType == EVENT_TYPE_CLICK) {
          scheduleHideTapHighlightLocked();
        }
      }

      // Handle the event.
      if (event != null) {
        dispatchUiEvent(event, eventType, flags);
        event.recycle();
      }
    }
  }

  // Runs on UI thread.
  private void dispatchUiEvent(MotionEvent event, int eventType, int flags) {
    if (DEBUG) {
      Log.d(
          TAG, "dispatchUiEvent: event=" + event + ", eventType=" + eventType + ", flags=" + flags);
    }
    mUiCallbacks.dispatchUiEvent(event, eventType, flags);
  }

  private void enqueueEventLocked(DispatchEvent d) {
    if (!shouldSkipWebKit(d)) {
      enqueueWebKitEventLocked(d);
    } else {
      enqueueUiEventLocked(d);
    }
  }

  private boolean shouldSkipWebKit(DispatchEvent d) {
    switch (d.mEventType) {
      case EVENT_TYPE_CLICK:
      case EVENT_TYPE_HOVER:
      case EVENT_TYPE_SCROLL:
      case EVENT_TYPE_HIT_TEST:
        return false;
      case EVENT_TYPE_TOUCH:
        // TODO: This should be cleaned up. We now have WebViewInputDispatcher
        // and WebViewClassic both checking for slop and doing their own
        // thing - they should be consolidated. And by consolidated, I mean
        // WebViewClassic's version should just be deleted.
        // The reason this is done is because webpages seem to expect
        // that they only get an ontouchmove if the slop has been exceeded.
        if (mIsTapCandidate
            && d.mEvent != null
            && d.mEvent.getActionMasked() == MotionEvent.ACTION_MOVE) {
          return true;
        }
        return !mPostSendTouchEventsToWebKit || mPostDoNotSendTouchEventsToWebKitUntilNextGesture;
    }
    return true;
  }

  private void enqueueWebKitCancelTouchEventIfNeededLocked() {
    // We want to cancel touch events that were delivered to web kit.
    // Enqueue a null event at the end of the queue if needed.
    if (mWebKitTouchStream.isCancelNeeded() || !mWebKitDispatchEventQueue.isEmpty()) {
      DispatchEvent d = obtainDispatchEventLocked(null, EVENT_TYPE_TOUCH, FLAG_PRIVATE, 0, 0, 1.0f);
      enqueueWebKitEventUnbatchedLocked(d);
      mPostDoNotSendTouchEventsToWebKitUntilNextGesture = true;
    }
  }

  private void enqueueWebKitEventLocked(DispatchEvent d) {
    if (batchEventLocked(d, mWebKitDispatchEventQueue.mTail)) {
      if (DEBUG) {
        Log.d(TAG, "enqueueWebKitEventLocked: batched event " + d.mEvent);
      }
      recycleDispatchEventLocked(d);
    } else {
      enqueueWebKitEventUnbatchedLocked(d);
    }
  }

  private void enqueueWebKitEventUnbatchedLocked(DispatchEvent d) {
    if (DEBUG) {
      Log.d(TAG, "enqueueWebKitEventUnbatchedLocked: enqueued event " + d.mEvent);
    }
    mWebKitDispatchEventQueue.enqueue(d);
    scheduleWebKitDispatchLocked();
    updateWebKitTimeoutLocked();
  }

  private void scheduleWebKitDispatchLocked() {
    if (!mWebKitDispatchScheduled) {
      mWebKitHandler.sendEmptyMessage(WebKitHandler.MSG_DISPATCH_WEBKIT_EVENTS);
      mWebKitDispatchScheduled = true;
    }
  }

  private void updateWebKitTimeoutLocked() {
    DispatchEvent d = mWebKitDispatchEventQueue.mHead;
    if (d != null && mWebKitTimeoutScheduled && mWebKitTimeoutTime == d.mTimeoutTime) {
      return;
    }
    if (mWebKitTimeoutScheduled) {
      mUiHandler.removeMessages(UiHandler.MSG_WEBKIT_TIMEOUT);
      mWebKitTimeoutScheduled = false;
    }
    if (d != null) {
      mUiHandler.sendEmptyMessageAtTime(UiHandler.MSG_WEBKIT_TIMEOUT, d.mTimeoutTime);
      mWebKitTimeoutScheduled = true;
      mWebKitTimeoutTime = d.mTimeoutTime;
    }
  }

  private void enqueueUiCancelTouchEventIfNeededLocked() {
    // We want to cancel touch events that were delivered to the UI.
    // Enqueue a null event at the end of the queue if needed.
    if (mUiTouchStream.isCancelNeeded() || !mUiDispatchEventQueue.isEmpty()) {
      DispatchEvent d = obtainDispatchEventLocked(null, EVENT_TYPE_TOUCH, FLAG_PRIVATE, 0, 0, 1.0f);
      enqueueUiEventUnbatchedLocked(d);
    }
  }

  private void enqueueUiEventLocked(DispatchEvent d) {
    if (batchEventLocked(d, mUiDispatchEventQueue.mTail)) {
      if (DEBUG) {
        Log.d(TAG, "enqueueUiEventLocked: batched event " + d.mEvent);
      }
      recycleDispatchEventLocked(d);
    } else {
      enqueueUiEventUnbatchedLocked(d);
    }
  }

  private void enqueueUiEventUnbatchedLocked(DispatchEvent d) {
    if (DEBUG) {
      Log.d(TAG, "enqueueUiEventUnbatchedLocked: enqueued event " + d.mEvent);
    }
    mUiDispatchEventQueue.enqueue(d);
    scheduleUiDispatchLocked();
  }

  private void scheduleUiDispatchLocked() {
    if (!mUiDispatchScheduled) {
      mUiHandler.sendEmptyMessage(UiHandler.MSG_DISPATCH_UI_EVENTS);
      mUiDispatchScheduled = true;
    }
  }

  private boolean batchEventLocked(DispatchEvent in, DispatchEvent tail) {
    if (!ENABLE_EVENT_BATCHING) {
      return false;
    }
    if (tail != null
        && tail.mEvent != null
        && in.mEvent != null
        && in.mEventType == tail.mEventType
        && in.mFlags == tail.mFlags
        && in.mWebKitXOffset == tail.mWebKitXOffset
        && in.mWebKitYOffset == tail.mWebKitYOffset
        && in.mWebKitScale == tail.mWebKitScale) {
      return tail.mEvent.addBatch(in.mEvent);
    }
    return false;
  }

  private DispatchEvent obtainDispatchEventLocked(
      MotionEvent event,
      int eventType,
      int flags,
      int webKitXOffset,
      int webKitYOffset,
      float webKitScale) {
    DispatchEvent d = obtainUninitializedDispatchEventLocked();
    d.mEvent = event;
    d.mEventType = eventType;
    d.mFlags = flags;
    d.mTimeoutTime = SystemClock.uptimeMillis() + WEBKIT_TIMEOUT_MILLIS;
    d.mWebKitXOffset = webKitXOffset;
    d.mWebKitYOffset = webKitYOffset;
    d.mWebKitScale = webKitScale;
    if (DEBUG) {
      Log.d(TAG, "Timeout time: " + (d.mTimeoutTime - SystemClock.uptimeMillis()));
    }
    return d;
  }

  private DispatchEvent copyDispatchEventLocked(DispatchEvent d) {
    DispatchEvent copy = obtainUninitializedDispatchEventLocked();
    if (d.mEvent != null) {
      copy.mEvent = d.mEvent.copy();
    }
    copy.mEventType = d.mEventType;
    copy.mFlags = d.mFlags;
    copy.mTimeoutTime = d.mTimeoutTime;
    copy.mWebKitXOffset = d.mWebKitXOffset;
    copy.mWebKitYOffset = d.mWebKitYOffset;
    copy.mWebKitScale = d.mWebKitScale;
    copy.mNext = d.mNext;
    return copy;
  }

  private DispatchEvent obtainUninitializedDispatchEventLocked() {
    DispatchEvent d = mDispatchEventPool;
    if (d != null) {
      mDispatchEventPoolSize -= 1;
      mDispatchEventPool = d.mNext;
      d.mNext = null;
    } else {
      d = new DispatchEvent();
    }
    return d;
  }

  private void recycleDispatchEventLocked(DispatchEvent d) {
    if (d.mEvent != null) {
      d.mEvent.recycle();
      d.mEvent = null;
    }

    if (mDispatchEventPoolSize < MAX_DISPATCH_EVENT_POOL_SIZE) {
      mDispatchEventPoolSize += 1;
      d.mNext = mDispatchEventPool;
      mDispatchEventPool = d;
    }
  }

  /* Implemented by {@link WebViewClassic} to perform operations on the UI thread. */
  public static interface UiCallbacks {
    /**
     * Gets the UI thread's looper.
     *
     * @return The looper.
     */
    public Looper getUiLooper();

    /**
     * Gets the UI's context
     *
     * @return The context
     */
    public Context getContext();

    /**
     * Dispatches an event to the UI.
     *
     * @param event The event.
     * @param eventType The event type.
     * @param flags The event's dispatch flags.
     */
    public void dispatchUiEvent(MotionEvent event, int eventType, int flags);

    /**
     * Asks the UI thread whether this touch event stream should be intercepted based on the touch
     * down event.
     *
     * @param event The touch down event.
     * @return true if the UI stream wants the touch stream without going through webkit or false
     *     otherwise.
     */
    public boolean shouldInterceptTouchEvent(MotionEvent event);

    /**
     * Inform's the UI that it should show the tap highlight
     *
     * @param show True if it should show the highlight, false if it should hide it
     */
    public void showTapHighlight(boolean show);

    /**
     * Called when we are sending a new EVENT_TYPE_HIT_TEST to WebKit, so previous hit tests should
     * be cleared as they are obsolete.
     */
    public void clearPreviousHitTest();
  }

  /* Implemented by {@link WebViewCore} to perform operations on the web kit thread. */
  public static interface WebKitCallbacks {
    /**
     * Gets the web kit thread's looper.
     *
     * @return The looper.
     */
    public Looper getWebKitLooper();

    /**
     * Dispatches an event to web kit.
     *
     * @param dispatcher The WebViewInputDispatcher sending the event
     * @param event The event.
     * @param eventType The event type.
     * @param flags The event's dispatch flags.
     * @return True if web kit wants to prevent default event handling.
     */
    public boolean dispatchWebKitEvent(
        WebViewInputDispatcher dispatcher, MotionEvent event, int eventType, int flags);
  }

  // Runs on UI thread.
  private final class UiHandler extends Handler {
    public static final int MSG_DISPATCH_UI_EVENTS = 1;
    public static final int MSG_WEBKIT_TIMEOUT = 2;
    public static final int MSG_LONG_PRESS = 3;
    public static final int MSG_CLICK = 4;
    public static final int MSG_SHOW_TAP_HIGHLIGHT = 5;
    public static final int MSG_HIDE_TAP_HIGHLIGHT = 6;

    public UiHandler(Looper looper) {
      super(looper);
    }

    @Override
    public void handleMessage(Message msg) {
      switch (msg.what) {
        case MSG_DISPATCH_UI_EVENTS:
          dispatchUiEvents(true);
          break;
        case MSG_WEBKIT_TIMEOUT:
          handleWebKitTimeout();
          break;
        case MSG_LONG_PRESS:
          postLongPress();
          break;
        case MSG_CLICK:
          postClick();
          break;
        case MSG_SHOW_TAP_HIGHLIGHT:
          postShowTapHighlight(true);
          break;
        case MSG_HIDE_TAP_HIGHLIGHT:
          postShowTapHighlight(false);
          break;
        default:
          throw new IllegalStateException("Unknown message type: " + msg.what);
      }
    }
  }

  // Runs on web kit thread.
  private final class WebKitHandler extends Handler {
    public static final int MSG_DISPATCH_WEBKIT_EVENTS = 1;

    public WebKitHandler(Looper looper) {
      super(looper);
    }

    @Override
    public void handleMessage(Message msg) {
      switch (msg.what) {
        case MSG_DISPATCH_WEBKIT_EVENTS:
          dispatchWebKitEvents(true);
          break;
        default:
          throw new IllegalStateException("Unknown message type: " + msg.what);
      }
    }
  }

  private static final class DispatchEvent {
    public DispatchEvent mNext;

    public MotionEvent mEvent;
    public int mEventType;
    public int mFlags;
    public long mTimeoutTime;
    public int mWebKitXOffset;
    public int mWebKitYOffset;
    public float mWebKitScale;
  }

  private static final class DispatchEventQueue {
    public DispatchEvent mHead;
    public DispatchEvent mTail;

    public boolean isEmpty() {
      return mHead != null;
    }

    public void enqueue(DispatchEvent d) {
      if (mHead == null) {
        mHead = d;
        mTail = d;
      } else {
        mTail.mNext = d;
        mTail = d;
      }
    }

    public DispatchEvent dequeue() {
      DispatchEvent d = mHead;
      if (d != null) {
        DispatchEvent next = d.mNext;
        if (next == null) {
          mHead = null;
          mTail = null;
        } else {
          mHead = next;
          d.mNext = null;
        }
      }
      return d;
    }

    public DispatchEvent dequeueList() {
      DispatchEvent d = mHead;
      if (d != null) {
        mHead = null;
        mTail = null;
      }
      return d;
    }
  }

  /**
   * Keeps track of a stream of touch events so that we can discard touch events that would make the
   * stream inconsistent.
   */
  private static final class TouchStream {
    private MotionEvent mLastEvent;

    /**
     * Gets the last touch event that was delivered.
     *
     * @return The last touch event, or null if none.
     */
    public MotionEvent getLastEvent() {
      return mLastEvent;
    }

    /**
     * Updates the touch event stream.
     *
     * @param event The event that we intend to send, or null to cancel the touch event stream.
     * @return The event that we should actually send, or null if no event should be sent because
     *     the proposed event would make the stream inconsistent.
     */
    public MotionEvent update(MotionEvent event) {
      if (event == null) {
        if (isCancelNeeded()) {
          event = mLastEvent;
          if (event != null) {
            event.setAction(MotionEvent.ACTION_CANCEL);
            mLastEvent = null;
          }
        }
        return event;
      }

      switch (event.getActionMasked()) {
        case MotionEvent.ACTION_MOVE:
        case MotionEvent.ACTION_UP:
        case MotionEvent.ACTION_POINTER_DOWN:
        case MotionEvent.ACTION_POINTER_UP:
          if (mLastEvent == null || mLastEvent.getAction() == MotionEvent.ACTION_UP) {
            return null;
          }
          updateLastEvent(event);
          return event;

        case MotionEvent.ACTION_DOWN:
          updateLastEvent(event);
          return event;

        case MotionEvent.ACTION_CANCEL:
          if (mLastEvent == null) {
            return null;
          }
          updateLastEvent(null);
          return event;

        default:
          return null;
      }
    }

    /**
     * Returns true if there is a gesture in progress that may need to be canceled.
     *
     * @return True if cancel is needed.
     */
    public boolean isCancelNeeded() {
      return mLastEvent != null && mLastEvent.getAction() != MotionEvent.ACTION_UP;
    }

    private void updateLastEvent(MotionEvent event) {
      if (mLastEvent != null) {
        mLastEvent.recycle();
      }
      mLastEvent = event != null ? MotionEvent.obtainNoHistory(event) : null;
    }
  }

  /**
   * M: Keeps track of a stream of touch events so that we can prevent Ui to handle events that
   * previous event is also prevent.
   */
  private static final class PreventTouchStream {
    private boolean mLastPreventDefault;

    public boolean getLastPreventDefault() {
      return mLastPreventDefault;
    }
    /**
     * Update the prevent touch stream.
     *
     * @param event The event that webkit had handled, or null to drop it.
     * @param preventDefault Prevent Ui to handle this event or not.
     * @return true If last event if prevented or false if not..
     */
    public boolean update(MotionEvent event, boolean preventDefault) {
      // Don't prevent null event.
      if (event == null) {
        Log.e(TAG, "PreventTouchStream has null event.");
        return false;
      }

      if (DEBUG) {
        Log.d(TAG, "event action=" + event.getActionMasked() + " preventDefault=" + preventDefault);
      }

      boolean prevent = mLastPreventDefault;
      mLastPreventDefault = preventDefault;
      switch (event.getActionMasked()) {
        case MotionEvent.ACTION_DOWN:
        case MotionEvent.ACTION_MOVE:
        case MotionEvent.ACTION_POINTER_DOWN:
        case MotionEvent.ACTION_POINTER_UP:
          return prevent;
        case MotionEvent.ACTION_UP:
        case MotionEvent.ACTION_CANCEL:
          mLastPreventDefault = false;
          return prevent;
        default:
          return preventDefault;
      }
    }
  }
}
 @Override
 public boolean onTouchEvent(MotionEvent ev) {
     int action = ev.getAction();
     boolean handled = false;
     switch (action) {
         case MotionEvent.ACTION_DOWN: {
             View v = getCurrentView();
             if (v != null) {
                 if (isTransformedTouchPointInView(ev.getX(), ev.getY(), v, null)) {
                     if (mPendingCheckForTap == null) {
                         mPendingCheckForTap = new CheckForTap();
                     }
                     mTouchMode = TOUCH_MODE_DOWN_IN_CURRENT_VIEW;
                     postDelayed(mPendingCheckForTap, ViewConfiguration.getTapTimeout());
                 }
             }
             break;
         }
         case MotionEvent.ACTION_MOVE: break;
         case MotionEvent.ACTION_POINTER_UP: break;
         case MotionEvent.ACTION_UP: {
             if (mTouchMode == TOUCH_MODE_DOWN_IN_CURRENT_VIEW) {
                 final View v = getCurrentView();
                 final ViewAndMetaData viewData = getMetaDataForChild(v);
                 if (v != null) {
                     if (isTransformedTouchPointInView(ev.getX(), ev.getY(), v, null)) {
                         final Handler handler = getHandler();
                         if (handler != null) {
                             handler.removeCallbacks(mPendingCheckForTap);
                         }
                         showTapFeedback(v);
                         postDelayed(new Runnable() {
                             public void run() {
                                 hideTapFeedback(v);
                                 post(new Runnable() {
                                     public void run() {
                                         if (viewData != null) {
                                             performItemClick(v, viewData.adapterPosition,
                                                     viewData.itemId);
                                         } else {
                                             performItemClick(v, 0, 0);
                                         }
                                     }
                                 });
                             }
                         }, ViewConfiguration.getPressedStateDuration());
                         handled = true;
                     }
                 }
             }
             mTouchMode = TOUCH_MODE_NONE;
             break;
         }
         case MotionEvent.ACTION_CANCEL: {
             View v = getCurrentView();
             if (v != null) {
                 hideTapFeedback(v);
             }
             mTouchMode = TOUCH_MODE_NONE;
         }
     }
     return handled;
 }