阻止OnLongClickListener在拖动时触发

Question

我有一个包含位图的自定义视图，用户可以拖动它们。

我希望当他们长按其中一个时，我可以弹出一个上下文菜单，其中包括重置位置等选项。

在自定义视图中，我添加了我的OnLongClickListener：

this.setOnLongClickListener(new View.OnLongClickListener() {
    @Override
    public boolean onLongClick(View v) {
        // show context menu..
        return true;
    }
});

并覆盖onTouchEvent，使其类似于以下内容：

public boolean onTouchEvent(MotionEvent event) {
    handleDrag(event);
    super.onTouchEvent(event);
    return true;
}

handleDrag函数会找到被按下的对象，并处理更新它的位置。

我的问题是，当我开始拖动一个图片时，OnLongClickListener也会触发。我不确定最好的解决方法是什么。

我尝试给handleDrag添加一个阈值，如果用户按下但没有尝试拖动，则返回false，但我发现很难触发正确的处理程序。

有人能建议一种在拖动时跳过OnLongClickListener的方法吗？

- brk3

Answer 1

我认为通过调整我的阈值方法，我已经解决了这个问题。

首先，我将我的onTouchEvent更改为以下方式：

 public boolean onTouchEvent(MotionEvent event) {
     mMultiTouchController.handleDrag(event);
     return super.onTouchEvent(event);
 }

现在它们都触发了，所以我将我的OnLongClickListener更改为以下内容：

 this.setOnLongClickListener(new View.OnLongClickListener() {
     @Override
     public boolean onLongClick(View v) {
         if (!mMultiTouchController.has_moved) {
             // Pop menu and done...
             return false;
         }
         return true;
     }
 });

(mMultiTouchController是包含所有手势检测代码的类)。关键在于我添加了布尔值“has_moved”在这个类中。当我开始拖动时，我计算出delta：

 float diffX = Math.abs(mCurrPtX - mPrevPt.getX());
 float diffY = Math.abs(mCurrPtY - mPrevPt.getY());
 if (diffX < threshold && diffY < threshold) {
     has_moved = false;
     return;
 }

现在当onLongClick触发时，我知道是否需要采取行动。

最后一步是设置：

setHapticFeedbackEnabled(false);

在我的观点中，为了避免用户在长按触发但没有采取任何动作时得到震动。我计划作为下一步手动进行震动。

目前看来这个方法似乎可行，希望能帮助到遇到类似情况的人。

- brk3

Answer 2

我建议您停止使用onLongClickListener，而是自己实现一个，这很容易做到。这样，您就可以控制它们不会相互干扰。

以下代码实现了以下手势：拖动、轻击、双击、长按和捏合。

static final short NONE = 0;
static final short DRAG = 1;
static final short ZOOM = 2;
static final short TAP = 3;
static final short DOUBLE_TAP = 4;
static final short POST_GESTURE = 5;
short mode = NONE;
static final float MIN_PINCH_DISTANCE = 30f;
static final float MIN_DRAG_DISTANCE = 5f;
static final float DOUBLE_TAP_MAX_DISTANCE = 30f;
static final long MAX_DOUBLE_TAP_MS = 1000;
static final long LONG_PRESS_THRESHOLD_MS = 2000;

public class Vector2d {
    public float x;
    public float y;

    public Vector2d() {
        x = 0f;
        y = 0f;
    }

    public void set(float newX, float newY) {
        x = newX;
        y = newY;
    }

    public Vector2d avgVector(Vector2d remote) {
        Vector2d mid = new Vector2d();
        mid.set((remote.x + x)/2, (remote.y + y)/2);
        return mid;
    }

    public float length() {
        return (float) Math.sqrt(x * x + y * y);
    }

    public float distance(Vector2d remote) {
        float deltaX = remote.x - x;
        float deltaY = remote.y - y;
        return (float) Math.sqrt(deltaX * deltaX + deltaY * deltaY);
    }
}

private Vector2d finger1 = new Vector2d();
private Vector2d finger2 = new Vector2d();
private Vector2d pinchStartDistance = new Vector2d();
private Vector2d pinchMidPoint;
private Vector2d fingerStartPoint = new Vector2d();
private long gestureStartTime;
private Marker selectedMarker;

@Override
public boolean onTouch(View v, MotionEvent event) {
    // Dump touch event to log
    dumpEvent(event);

    // Handle touch events here...
    switch (event.getAction() & MotionEvent.ACTION_MASK) {
    case MotionEvent.ACTION_DOWN:
        finger1.set(event.getX(), event.getY());
        if (mode == TAP) {
            if (finger1.distance(fingerStartPoint) < DOUBLE_TAP_MAX_DISTANCE) {
                mode = DOUBLE_TAP;
            } else {
                mode = NONE;
                gestureStartTime = SystemClock.uptimeMillis();
            }
        } else {
            gestureStartTime = SystemClock.uptimeMillis();
        }
        fingerStartPoint.set(event.getX(), event.getY());
        break;
    case MotionEvent.ACTION_POINTER_DOWN:
        finger2.set(event.getX(1), event.getY(1));

        pinchStartDistance.set(Math.abs(finger1.x - finger2.x), Math.abs(finger1.y - finger2.y));
        Log.d(TAG, String.format("pinch start distance = %f, %f", pinchStartDistance.x, pinchStartDistance.y));
        if (pinchStartDistance.length() > MIN_PINCH_DISTANCE) {
            if (pinchStartDistance.x < MIN_PINCH_DISTANCE) {
                pinchStartDistance.x = MIN_PINCH_DISTANCE;
            }
            if (pinchStartDistance.y < MIN_PINCH_DISTANCE) {
                pinchStartDistance.y = MIN_PINCH_DISTANCE;
            }
            pinchMidPoint = finger1.avgVector(finger2);
            mode = ZOOM;
            Log.d(TAG, "mode=ZOOM" );
        }
        break;
    case MotionEvent.ACTION_UP:
    case MotionEvent.ACTION_POINTER_UP:
        if (mode == ZOOM) {
            Vector2d pinchEndDistance = new Vector2d();
            pinchEndDistance.set(Math.abs(finger1.x - finger2.x), Math.abs(finger1.y - finger2.y));
            if (pinchEndDistance.x < MIN_PINCH_DISTANCE) {
                pinchEndDistance.x = MIN_PINCH_DISTANCE;
            }
            if (pinchEndDistance.y < MIN_PINCH_DISTANCE) {
                pinchEndDistance.y = MIN_PINCH_DISTANCE;
            }
            Log.d(TAG, String.format("pinch end distance = %f, %f", pinchEndDistance.x, pinchEndDistance.y));
            zoom(pinchMidPoint, pinchStartDistance.x/pinchEndDistance.x, pinchStartDistance.y/pinchEndDistance.y);
            // Set mode to "POST_GESTURE" so that when the other finger lifts the handler won't think it was a
            // tap or something.
            mode = POST_GESTURE;
        } else if (mode == NONE) {
            // The finger wasn't moved enough for it to be considered a "drag", so it is either a tap
            // or a "long press", depending on how long it was down.
            if ((SystemClock.uptimeMillis() - gestureStartTime) < LONG_PRESS_THRESHOLD_MS) {
                Log.d(TAG, "mode=TAP");
                mode = TAP;
                selectedMarker = checkForMarker(finger1);
                if (selectedMarker != null) {
                    Log.d(TAG, "Selected marker, mode=NONE");
                    mode = NONE;
                    ((Activity) parent).showDialog(ResultsActivity.DIALOG_MARKER_ID);
                }
            }
            else {
                Log.d(TAG, "mode=LONG_PRESS");
                addMarker(finger1);
                requestRender();
            }
        } else if (mode == DOUBLE_TAP && (SystemClock.uptimeMillis() - gestureStartTime) < MAX_DOUBLE_TAP_MS) {
            // The finger was again not moved enough for it to be considered a "drag", so it is
            // a double-tap.  Change the center point and zoom in.
            Log.d(TAG, "mode=DOUBLE_TAP");
            zoom(fingerStartPoint, 0.5f, 0.5f);
            mode = NONE;
        } else {
            mode = NONE;
            Log.d(TAG, "mode=NONE" );
        }
        break;
    case MotionEvent.ACTION_MOVE:
        if (mode == NONE || mode == TAP || mode == DOUBLE_TAP) {
            finger1.set(event.getX(), event.getY());
            if (finger1.distance(fingerStartPoint) > MIN_DRAG_DISTANCE) {
                Log.d(TAG, "mode=DRAG" );
                mode = DRAG;
                scroll(fingerStartPoint.x - finger1.x, fingerStartPoint.y - finger1.y);
            }
        }
        else if (mode == DRAG) {
            scroll(finger1.x - event.getX(), finger1.y - event.getY());
            finger1.set(event.getX(), event.getY());
        }
        else if (mode == ZOOM) {
            for (int i=0; i<event.getPointerCount(); i++) {
                if (event.getPointerId(i) == 0) {
                    finger1.set(event.getX(i), event.getY(i));
                }
                else if (event.getPointerId(i) == 1) {
                    finger2.set(event.getX(i), event.getY(i));
                }
                else {
                    Log.w(TAG, String.format("Unknown motion event pointer id: %d", event.getPointerId(i)));
                }
            }
        }
        break;
    }

    return true;
}

/** Show an event in the LogCat view, for debugging */
private void dumpEvent(MotionEvent event) {
   String names[] = { "DOWN" , "UP" , "MOVE" , "CANCEL" , "OUTSIDE" ,
      "POINTER_DOWN" , "POINTER_UP" , "7?" , "8?" , "9?" };
   StringBuilder sb = new StringBuilder();
   int action = event.getAction();
   int actionCode = action & MotionEvent.ACTION_MASK;
   sb.append("event ACTION_" ).append(names[actionCode]);
   if (actionCode == MotionEvent.ACTION_POINTER_DOWN
         || actionCode == MotionEvent.ACTION_POINTER_UP) {
      sb.append("(pid " ).append(
      action >> MotionEvent.ACTION_POINTER_ID_SHIFT);
      sb.append(")" );
   }
   sb.append("[" );
   for (int i = 0; i < event.getPointerCount(); i++) {
      sb.append("#" ).append(i);
      sb.append("(pid " ).append(event.getPointerId(i));
      sb.append(")=" ).append((int) event.getX(i));
      sb.append("," ).append((int) event.getY(i));
      if (i + 1 < event.getPointerCount())
         sb.append(";" );
   }
   sb.append("]" );
   Log.d(TAG, sb.toString());
}

- Jim Clay

Answer 3

//这段代码用于处理手势检测

final Handler handler = new Handler();
private Runnable mLongPressRunnable;

detector = new GestureDetector(this, new MyGestureDectector());
view.setOnTouchListener(new OnTouchListener() {

        @SuppressLint("ClickableViewAccessibility")
        @SuppressWarnings("deprecation")
        @Override
        public boolean onTouch(View v, MotionEvent event) {
            detector.onTouchEvent(event);
            if (event.getAction() == MotionEvent.ACTION_DOWN) {

                handler.postDelayed(mLongPressRunnable, 1000);
            }
            if ((event.getAction() == MotionEvent.ACTION_MOVE)
                    || (event.getAction() == MotionEvent.ACTION_UP)) {
                handler.removeCallbacks(mLongPressRunnable);

                }

            }

            return true;
        }
    });
mLongPressRunnable = new Runnable() {
        public void run() {
            Toast.makeText(MainActivity.this, "long", Toast.LENGTH_SHORT)
                    .show();
        }
    };
class MyGestureDectector implements GestureDetector.OnDoubleTapListener,
        OnGestureListener {
        //Implement all the methods
        }

- Vivek E

---

注意：我发现在至少一个设备上，即使我不移动手指，down事件后几乎立即触发了move事件。因此，我建议不要在收到move事件时立即取消长按事件（removeCallbacks实际上是一个取消）。相反，请执行“移动阈值”方法的某些变化，如“接受”答案所示。该答案的handler postDelayed/removeCallbacks方法可以适应此移动阈值。 - ToolmakerSteve