@Override
public boolean onTouchEvent(MotionEvent event) {
int action = event.getAction();
boolean flag = false;
switch (action) {
case MotionEvent.ACTION_DOWN:
try {
MovementMethod m = getMovementMethod();
setMovementMethod(null);
CharSequence sequence = getText();
if (sequence instanceof Spannable) {
boolean mt = m.onTouchEvent(this, (Spannable) getText(), event);
if (mt) {
event.setAction(MotionEvent.ACTION_UP);
mt = m.onTouchEvent(this, (Spannable) getText(), event);
event.setAction(MotionEvent.ACTION_DOWN);
}
boolean st = super.onTouchEvent(event);
setMovementMethod(m);
setFocusable(false);
flag = mt || st;
}
} catch (Exception e) {
}
break;
default:
break;
}
return flag;
}
@Override
public boolean dispatchTouchEvent(MotionEvent event) {
boolean ret = false;
if (mIsScroll && event.getAction() == MotionEvent.ACTION_UP) {
if (mScrollX > 0 && mScrollX < mMaxDistance) {
unFold();
ret = true;
}
event.setAction(MotionEvent.ACTION_CANCEL);
mIsScroll = false;
} else if (mGestureDetector != null && mGestureDetector.onTouchEvent(event)) {
event.setAction(MotionEvent.ACTION_CANCEL);
ret = true;
}
if (super.dispatchTouchEvent(event)) {
ret = true;
}
if (ret) {
invalidate();
}
return ret;
}
private boolean resetDispatchTouchEvent(MotionEvent ev) {
MotionEvent newEvent = MotionEvent.obtain(ev);
ev.setAction(MotionEvent.ACTION_CANCEL);
dispatchTouchEvent(ev);
newEvent.setAction(MotionEvent.ACTION_DOWN);
return dispatchTouchEvent(newEvent);
}
public void onTouchEvent(final MotionEvent event) {
if (!_running) return;
boolean result = _detector.onTouchEvent(event);
if (_mode == MODE_SOLID) event.setAction(MotionEvent.ACTION_CANCEL);
else if (_mode == MODE_DYNAMIC) {
if (event.getAction() == ACTION_FAKE) event.setAction(MotionEvent.ACTION_UP);
else if (result) event.setAction(MotionEvent.ACTION_CANCEL);
else if (_tapIndicator) {
event.setAction(MotionEvent.ACTION_DOWN);
_tapIndicator = false;
}
}
}
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);
}
}
protected boolean dispatchTouchEvent(MotionEvent event) {
int x = (int) event.getX();
int y = (int) event.getY();
int action = event.getAction();
if (mMotionTarget != null) {
if (action == MotionEvent.ACTION_DOWN) {
MotionEvent cancel = MotionEvent.obtain(event);
cancel.setAction(MotionEvent.ACTION_CANCEL);
dispatchTouchEvent(cancel, x, y, mMotionTarget, false);
mMotionTarget = null;
} else {
dispatchTouchEvent(event, x, y, mMotionTarget, false);
if (action == MotionEvent.ACTION_CANCEL || action == MotionEvent.ACTION_UP) {
mMotionTarget = null;
}
return true;
}
}
if (action == MotionEvent.ACTION_DOWN) {
// in the reverse rendering order
for (int i = getComponentCount() - 1; i >= 0; --i) {
GLView component = getComponent(i);
if (component.getVisibility() != GLView.VISIBLE) continue;
if (dispatchTouchEvent(event, x, y, component, true)) {
mMotionTarget = component;
return true;
}
}
}
return onTouch(event);
}
@Override
public boolean dispatchTouchEvent(MotionEvent event) {
if (!onFilterTouchEventForSecurity(event)) return false;
int action = event.getAction();
double dx = event.getX() - mCenterX;
double dy = mCenterY - event.getY();
double radius = Math.sqrt(dx * dx + dy * dy);
// Check if the event should be dispatched to the shutter button.
if (radius <= mShutterButtonRadius) {
if (mIndicatorControlWheel.getVisibility() == View.VISIBLE) {
mIndicatorControlWheel.onTouchOutBound();
}
if (action == MotionEvent.ACTION_DOWN || action == MotionEvent.ACTION_UP) {
return mShutterButton.dispatchTouchEvent(event);
}
return false;
}
if (mShutterButton.isPressed()) {
// Send cancel to the shutter button if it was pressed.
event.setAction(MotionEvent.ACTION_CANCEL);
mShutterButton.dispatchTouchEvent(event);
return true;
}
return mIndicatorControlWheel.dispatchTouchEvent(event);
}
@Override
public boolean onSingleTapConfirmed(final MotionEvent arg0) {
if (_mode == MODE_DYNAMIC) { // we owe an ACTION_UP, so we fake an
arg0.setAction(ACTION_FAKE); // action which will be converted to an ACTION_UP later.
_context.dispatchTouchEvent(arg0);
}
return false;
}
public boolean onTouch(View view, MotionEvent motionevent)
{
view = d.e(b);
if (b.o() && !view.g(view.f()) && a.onTouchEvent(motionevent))
{
motionevent.setAction(3);
}
return false;
}
public void onTouchEvent(MotionEvent event) {
if (!this.running) return;
boolean result = this.detector.onTouchEvent(event);
if (this.mode == MODE_SOLID) event.setAction(MotionEvent.ACTION_CANCEL);
else if (this.mode == MODE_DYNAMIC) {
if (event.getAction() == ACTION_FAKE) event.setAction(MotionEvent.ACTION_UP);
else if (result) event.setAction(MotionEvent.ACTION_CANCEL);
else if (this.tapIndicator) {
event.setAction(MotionEvent.ACTION_DOWN);
this.tapIndicator = false;
}
}
// else just do nothing, it's Transparent
}
@Override
public boolean dispatchTouchEvent(MotionEvent ev) {
final float x = ev.getX();
final float y = ev.getY();
final int action = ev.getAction();
if (action == MotionEvent.ACTION_DOWN
&& mTouchTarget == null
&& mPinnedSection != null
&& isPinnedViewTouched(mPinnedSection.view, x, y)) { // create touch target
// user touched pinned view
mTouchTarget = mPinnedSection.view;
mTouchPoint.x = x;
mTouchPoint.y = y;
// copy down event for eventually be used later
mDownEvent = MotionEvent.obtain(ev);
}
if (mTouchTarget != null) {
if (isPinnedViewTouched(mTouchTarget, x, y)) { // forward event to pinned view
mTouchTarget.dispatchTouchEvent(ev);
}
if (action == MotionEvent.ACTION_UP) { // perform onClick on pinned view
super.dispatchTouchEvent(ev);
performPinnedItemClick();
clearTouchTarget();
} else if (action == MotionEvent.ACTION_CANCEL) { // cancel
clearTouchTarget();
} else if (action == MotionEvent.ACTION_MOVE) {
if (Math.abs(y - mTouchPoint.y) > mTouchSlop) {
// cancel sequence on touch target
MotionEvent event = MotionEvent.obtain(ev);
event.setAction(MotionEvent.ACTION_CANCEL);
mTouchTarget.dispatchTouchEvent(event);
event.recycle();
// provide correct sequence to super class for further handling
super.dispatchTouchEvent(mDownEvent);
super.dispatchTouchEvent(ev);
clearTouchTarget();
}
}
return true;
}
// call super if this was not our pinned view
return super.dispatchTouchEvent(ev);
}
@Override
public boolean onSingleTapConfirmed(MotionEvent me) {
if (this.mode == MODE_DYNAMIC) { // we owe an ACTION_UP, so we fake an
me.setAction(ACTION_FAKE); // action which will be converted to an
// ACTION_UP later.
this.context.dispatchTouchEvent(me);
}
return false;
}
@Override
public boolean onInterceptTouchEvent(MotionEvent ev) {
MotionEvent cancellation = MotionEvent.obtain(ev);
cancellation.setAction(MotionEvent.ACTION_CANCEL);
boolean intercept = mExpandHelper.onInterceptTouchEvent(ev) || super.onInterceptTouchEvent(ev);
if (intercept) {
latestItems.onInterceptTouchEvent(cancellation);
}
return intercept;
}
@Override
public boolean onHoverEvent(MotionEvent event) {
// if (AccessibilityManager.getInstance(mContext).isTouchExplorationEnabled()) {
final int action = event.getAction();
switch (action) {
case MotionEvent.ACTION_HOVER_ENTER:
event.setAction(MotionEvent.ACTION_DOWN);
break;
case MotionEvent.ACTION_HOVER_MOVE:
event.setAction(MotionEvent.ACTION_MOVE);
break;
case MotionEvent.ACTION_HOVER_EXIT:
event.setAction(MotionEvent.ACTION_UP);
break;
}
onTouchEvent(event);
event.setAction(action);
// }
return super.onHoverEvent(event);
}
@Override
public boolean dispatchTouchEvent(MotionEvent ev) {
Log.i(LOG_STRING, "touch event: " + ev.toString());
// + " eventTime: " + ev.getEventTime() + " downtime: " + ev.getDownTime());
// + " xraw: " + ev.getRawX() +" x: "+ev.getX()
// + " yraw: " + ev.getRawY() +" y: "+ev.getY());
// mDemonstration.addMotionEvent(ev);
Parcel parcel = Parcel.obtain();
parcel.writeParcelable(ev, Parcelable.PARCELABLE_WRITE_RETURN_VALUE);
// add motionevent to parcel
try {
if (mBinder == null) {
Log.e(LOG_STRING, "Null binder!");
}
mBinder.transact(DemonstrationService.MOTION_EVENT_CODE, parcel, null, IBinder.FLAG_ONEWAY);
} catch (RemoteException e) {
Log.e(LOG_STRING, "Error transacting with demonstration service: " + e.toString());
}
if (mExplorationEnabled) {
int pointers = ev.getPointerCount();
if (ev.getPointerCount() == 1) {
ViewGroup target = this;
if (ev.getAction() == MotionEvent.ACTION_OUTSIDE) {
ev.setAction(MotionEvent.ACTION_DOWN);
mDetector.onTouchEvent(ev);
ev.setAction(MotionEvent.ACTION_UP);
}
mDetector.onTouchEvent(ev);
return true;
}
ev = stripLastPointer(ev);
}
return super.dispatchTouchEvent(ev);
}
@Override
public boolean dispatchTouchEvent(final MotionEvent ev) {
if (ev.getAction() == MotionEvent.ACTION_POINTER_DOWN
|| ev.getAction() == MotionEvent.ACTION_POINTER_UP) {
System.out.println("cancelled");
ev.setAction(MotionEvent.ACTION_CANCEL);
return true;
}
return super.dispatchTouchEvent(ev);
}
public boolean onTouch(MotionEvent event) {
boolean ret = false;
if (isVisible()) {
ret = super.onTouch(event);
int action = event.getAction();
if (mOpenCancle) {
if (mClip && !touched(event.getX(), event.getY())) {
event.setAction(MotionEvent.ACTION_CANCEL);
}
}
for (ScreenElement ele : mElements) {
if (ele.isTickFinished && ele.onTouch(event)) {
ret = true;
}
}
if (mOpenCancle) {
event.setAction(action);
}
}
return ret;
}
@Override
public boolean dispatchTouchEvent(MotionEvent ev) {
if (((!mEnabled || !mInterceptTouch) && mMode == MODE_READY) || mAlwaysOpened) {
return super.dispatchTouchEvent(ev);
}
if (mMode != MODE_FINISHED) {
onTouchEvent(ev);
if (mMode != MODE_SLIDE) {
super.dispatchTouchEvent(ev);
} else {
MotionEvent cancelEvent = MotionEvent.obtain(ev);
cancelEvent.setAction(MotionEvent.ACTION_CANCEL);
super.dispatchTouchEvent(cancelEvent);
cancelEvent.recycle();
}
return true;
} else {
final int action = ev.getAction();
Rect rect = new Rect();
View menu = getChildAt(0);
menu.getHitRect(rect);
if (!rect.contains((int) ev.getX(), (int) ev.getY())) {
if (action == MotionEvent.ACTION_UP && mCloseOnRelease && !mDispatchWhenOpened) {
close();
mCloseOnRelease = false;
} else {
if (action == MotionEvent.ACTION_DOWN && !mDispatchWhenOpened) {
mCloseOnRelease = true;
}
onTouchEvent(ev);
}
if (mDispatchWhenOpened) {
super.dispatchTouchEvent(ev);
}
return true;
} else {
onTouchEvent(ev);
ev.offsetLocation(-menu.getLeft(), -menu.getTop());
menu.dispatchTouchEvent(ev);
return true;
}
}
}
@Override
public boolean dispatchTouchEvent(MotionEvent ev) {
int action = ev.getAction() & MotionEvent.ACTION_MASK;
if (action == MotionEvent.ACTION_DOWN) {
mDownY = ev.getY();
mHeaderOwnsTouch = mHeader != null && mDownY <= mHeader.getHeight() + mHeaderOffset;
}
boolean handled;
if (mHeaderOwnsTouch) {
if (mHeader != null && Math.abs(mDownY - ev.getY()) <= mTouchSlop) {
handled = mHeader.dispatchTouchEvent(ev);
} else {
if (mHeader != null) {
MotionEvent cancelEvent = MotionEvent.obtain(ev);
cancelEvent.setAction(MotionEvent.ACTION_CANCEL);
mHeader.dispatchTouchEvent(cancelEvent);
cancelEvent.recycle();
}
MotionEvent downEvent =
MotionEvent.obtain(
ev.getDownTime(),
ev.getEventTime(),
ev.getAction(),
ev.getX(),
mDownY,
ev.getMetaState());
downEvent.setAction(MotionEvent.ACTION_DOWN);
handled = mList.dispatchTouchEvent(downEvent);
downEvent.recycle();
mHeaderOwnsTouch = false;
}
} else {
handled = mList.dispatchTouchEvent(ev);
}
return handled;
}
/**
* Detect if the given {@link MotionEvent} is outside the boundaries of this window, which usually
* means we should dismiss.
*/
protected void detectEventOutside(MotionEvent event) {
if (event.getAction() == MotionEvent.ACTION_DOWN) {
// Only try detecting outside events on down-press
mDecor.getHitRect(mRect);
mRect.top = mRect.top + mShadowTouch;
mRect.bottom = mRect.bottom - mShadowTouch;
final int x = (int) event.getX();
final int y = (int) event.getY();
if (!mRect.contains(x, y)) {
event.setAction(MotionEvent.ACTION_OUTSIDE);
}
}
}
/** 添加触摸事件 点击之后 出现 清空editText的效果 */
@Override
public boolean onTouchEvent(MotionEvent paramMotionEvent) {
if ((this.dRight != null) && (paramMotionEvent.getAction() == 1)) {
this.rBounds = this.dRight.getBounds();
int i = (int) paramMotionEvent.getRawX(); // 距离屏幕的距离
// int i = (int) paramMotionEvent.getX();//距离边框的距离
if (i > getRight() - 3 * this.rBounds.width()) {
setText("");
paramMotionEvent.setAction(MotionEvent.ACTION_CANCEL);
}
}
return super.onTouchEvent(paramMotionEvent);
}
@Override
public boolean dispatchTouchEvent(MotionEvent event) {
int dx, dy;
if (isLoading) return super.dispatchTouchEvent(event);
int action = event.getAction();
switch (action) {
case MotionEvent.ACTION_DOWN:
x = (int) event.getX();
y = (int) event.getY();
currentView.loadUrl(Notice.TOUCHDOWN);
break;
case MotionEvent.ACTION_MOVE:
dx = (int) event.getX() - x;
dy = (int) event.getY() - y;
x = (int) event.getX();
y = (int) event.getY();
Log.d(TAG, "dx:" + dx + ",dy:" + dy);
if (dx > -5 && dx < 5 && dy > -5 && dy < 5) {
} else {
moved = true;
}
break;
case MotionEvent.ACTION_UP:
if (!moved) { // 直接点击的事件，模拟一个下去
Log.d(TAG, "click event");
event.setAction(MotionEvent.ACTION_DOWN);
currentView.dispatchTouchEvent(event);
event.setAction(MotionEvent.ACTION_UP);
currentView.dispatchTouchEvent(event);
}
moved = false;
x = (int) event.getX();
y = (int) event.getY();
currentView.loadUrl(Notice.TOUCHUP);
}
return true;
}
@Override
public boolean onTouch(View v, MotionEvent event) {
switch (event.getAction()) {
case MotionEvent.ACTION_DOWN:
downX = tempX = (int) event.getRawX();
downY = (int) event.getRawY();
break;
case MotionEvent.ACTION_MOVE:
int moveX = (int) event.getRawX();
int deltaX = tempX - moveX;
tempX = moveX;
if (Math.abs(moveX - downX) > mTouchSlop
&& Math.abs((int) event.getRawY() - downY) < mTouchSlop) {
isSilding = true;
if (isTouchOnAbsListView()) {
MotionEvent cancelEvent = MotionEvent.obtain(event);
cancelEvent.setAction(
MotionEvent.ACTION_CANCEL
| (event.getActionIndex() << MotionEvent.ACTION_POINTER_INDEX_SHIFT));
v.onTouchEvent(cancelEvent);
}
}
if (moveX - downX >= 0 && isSilding) {
mParentView.scrollBy(deltaX, 0);
if (isTouchOnScrollView() || isTouchOnAbsListView()) {
return true;
}
}
break;
case MotionEvent.ACTION_UP:
isSilding = false;
if (mParentView.getScrollX() <= -viewWidth / 2) {
isFinish = true;
scrollRight();
} else {
scrollOrigin();
isFinish = false;
}
break;
}
if (isTouchOnScrollView() || isTouchOnAbsListView()) {
return v.onTouchEvent(event);
}
return true;
}
/** 处理我们拖动ListView item的逻辑 */
@Override
public boolean onTouchEvent(MotionEvent ev) {
if (isSlide && slidePosition != AdapterView.INVALID_POSITION) {
System.out.println("touch-->" + "开始");
requestDisallowInterceptTouchEvent(true);
addVelocityTracker(ev);
final int action = ev.getAction();
int x = (int) ev.getX();
switch (action) {
case MotionEvent.ACTION_DOWN:
System.out.println("touch-->" + "down");
break;
case MotionEvent.ACTION_MOVE:
System.out.println("touch-->" + "move");
MotionEvent cancelEvent = MotionEvent.obtain(ev);
cancelEvent.setAction(
MotionEvent.ACTION_CANCEL
| (ev.getActionIndex() << MotionEvent.ACTION_POINTER_INDEX_SHIFT));
onTouchEvent(cancelEvent);
int deltaX = downX - x;
// 手指拖动itemView滚动, deltaX大于0向左滚动，小于0向右滚
itemView.scrollTo(deltaX, 0);
// 根据手指滑动的距离，调整透明度
itemView.setAlpha(1f - Math.abs((float) deltaX / screenWidth));
return true; // 拖动的时候ListView不滚动
case MotionEvent.ACTION_UP:
System.out.println("touch-->" + "up");
// 手指离开的时候就不响应左右滚动
isSlide = false;
int velocityX = getScrollVelocity();
if (velocityX > SNAP_VELOCITY) {
scrollRight();
} else if (velocityX < -SNAP_VELOCITY) {
scrollLeft();
} else {
scrollByDistanceX();
}
recycleVelocityTracker();
break;
}
}
// 否则直接交给ListView来处理onTouchEvent事件
return super.onTouchEvent(ev);
}
@Override
public boolean onHoverEvent(MotionEvent event) {
final AccessibilityManager accessibilityManager =
(AccessibilityManager) getContext().getSystemService(Context.ACCESSIBILITY_SERVICE);
if (accessibilityManager.isTouchExplorationEnabled()) {
final int action = event.getAction();
switch (action) {
case MotionEvent.ACTION_HOVER_ENTER:
event.setAction(MotionEvent.ACTION_DOWN);
break;
case MotionEvent.ACTION_HOVER_MOVE:
event.setAction(MotionEvent.ACTION_MOVE);
break;
case MotionEvent.ACTION_HOVER_EXIT:
event.setAction(MotionEvent.ACTION_UP);
break;
}
onTouchEvent(event);
event.setAction(action);
}
super.onHoverEvent(event);
return true;
}
@Override
public boolean onTouch(View v, MotionEvent ev) {
requestDisallowInterceptTouchEvent(true);
addVelocityTracker(ev);
final int action = ev.getAction();
int y = (int) ev.getY();
switch (action) {
case MotionEvent.ACTION_DOWN:
break;
case MotionEvent.ACTION_MOVE:
MotionEvent cancelEvent = MotionEvent.obtain(ev);
cancelEvent.setAction(
MotionEvent.ACTION_CANCEL
| (ev.getActionIndex() << MotionEvent.ACTION_POINTER_INDEX_SHIFT));
onTouchEvent(cancelEvent);
int deltaY = downY - y;
downY = y;
Log.e("move_distance", String.valueOf(deltaY));
// 手指拖动this滚动, deltaX大于0向左滚动，小于0向右滚
this.scrollBy(0, deltaY);
return true; // 拖动的时候ListView不滚动
case MotionEvent.ACTION_UP:
// int velocityY = getScrollVelocity();
// if (velocityY > SNAP_VELOCITY) {
// scrollDOWN();
// } else if (velocityY < -SNAP_VELOCITY) {
// scrollUP();
// } else {
// scrollByDistanceX();
// }
//
// recycleVelocityTracker();
// 手指离开的时候就不响应左右滚动
scrollByDistanceX();
isSlide = false;
break;
}
// 否则直接交给ListView来处理onTouchEvent事件
return super.onTouchEvent(ev);
}
@Override
public boolean onInterceptTouchEvent(MotionEvent event) {
switch (event.getAction()) {
case MotionEvent.ACTION_DOWN:
mInterceptTouchDownX = event.getRawX();
mInterceptTouchDownY = event.getRawY();
break;
case MotionEvent.ACTION_MOVE:
if (!mIsLoadingMore && (mCurrentRefreshStatus != RefreshStatus.REFRESHING)) {
if (mInterceptTouchDownX == -1) {
mInterceptTouchDownX = (int) event.getRawX();
}
if (mInterceptTouchDownY == -1) {
mInterceptTouchDownY = (int) event.getRawY();
}
int interceptTouchMoveDistanceY = (int) (event.getRawY() - mInterceptTouchDownY);
// 可以没有上拉加载更多，但是必须有下拉刷新，否则就不拦截事件
if (Math.abs(event.getRawX() - mInterceptTouchDownX)
< Math.abs(interceptTouchMoveDistanceY)
&& mRefreshHeaderView != null) {
if ((interceptTouchMoveDistanceY > 0 && shouldHandleRefresh())
|| (interceptTouchMoveDistanceY < 0 && shouldHandleLoadingMore())
|| (interceptTouchMoveDistanceY < 0 && !isWholeHeaderViewCompleteInvisible())
|| (interceptTouchMoveDistanceY > 0
&& shouldInterceptToMoveCustomHeaderViewDown())) {
// ACTION_DOWN时没有消耗掉事件，子控件会处于按下状态，这里设置ACTION_CANCEL，使子控件取消按下状态
event.setAction(MotionEvent.ACTION_CANCEL);
super.onInterceptTouchEvent(event);
return true;
}
}
}
break;
case MotionEvent.ACTION_CANCEL:
case MotionEvent.ACTION_UP:
// 重置
mInterceptTouchDownX = -1;
mInterceptTouchDownY = -1;
break;
}
return super.onInterceptTouchEvent(event);
}
@Override
public boolean onTouchEvent(final MotionEvent event) {
switch (event.getAction()) {
case MotionEvent.ACTION_DOWN:
break;
case MotionEvent.ACTION_MOVE:
final ViewGroup parent = (ViewGroup) getParent();
// if (parent.onInterceptTouchEvent(event)) {
event.setAction(MotionEvent.ACTION_DOWN);
post(
new Runnable() {
@Override
public void run() {
parent.dispatchTouchEvent(event);
}
});
// }
break;
}
return super.onTouchEvent(event);
}
/**
* 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;
}
}
@Override
public boolean onInterceptTouchEvent(MotionEvent ev) {
boolean intercept = false;
if (mDoubleTapToSleepEnabled) {
if (mService.getBarState() == StatusBarState.SHADE && ev.getY() < mStatusBarHeaderHeight) {
if (DEBUG) Log.w(TAG, "logging double tap gesture");
mDoubleTapGesture.onTouchEvent(ev);
}
}
final int h = getMeasuredHeight();
if (mDoubleTapToSleepLockScreen
&& mService.getBarState() == StatusBarState.KEYGUARD
&& (ev.getY() < (h / 3) || ev.getY() > (h - mStatusBarHeaderHeight))) {
if (DEBUG) Log.w(TAG, "logging lock screen double tap gesture");
mDoubleTapGesture.onTouchEvent(ev);
}
if (mNotificationPanel.isFullyExpanded()
&& mStackScrollLayout.getVisibility() == View.VISIBLE
&& mService.getBarState() == StatusBarState.KEYGUARD
&& !mService.isBouncerShowing()) {
intercept = mDragDownHelper.onInterceptTouchEvent(ev);
// wake up on a touch down event, if dozing
if (ev.getActionMasked() == MotionEvent.ACTION_DOWN) {
mService.wakeUpIfDozing(ev.getEventTime(), ev);
}
}
if (!intercept) {
super.onInterceptTouchEvent(ev);
}
if (intercept) {
MotionEvent cancellation = MotionEvent.obtain(ev);
cancellation.setAction(MotionEvent.ACTION_CANCEL);
mStackScrollLayout.onInterceptTouchEvent(cancellation);
mNotificationPanel.onInterceptTouchEvent(cancellation);
cancellation.recycle();
}
return intercept;
}
