Detectando una pulsación larga con Android

Actualmente estoy usando

onTouchEvent(MotionEvent event){ } 

para detectar cuando el usuario presiona mi glSurfaceView hay una manera de detectar cuando se hace un clic largo. Supongo que si no puedo encontrar mucho en los documentos de desarrollo, será un método de reparación. Algo así como registrar ACTION_DOWN y ver cuánto tiempo pasa antes de ACTION_UP.

¿Cómo se detectan prensas largas en Android usando OpenGL-ES?

Prueba esto:

 final GestureDetector gestureDetector = new GestureDetector(new GestureDetector.SimpleOnGestureListener() { public void onLongPress(MotionEvent e) { Log.e("", "Longpress detected"); } }); public boolean onTouchEvent(MotionEvent event) { return gestureDetector.onTouchEvent(event); }; 

GestureDetector es la mejor solución.

Aquí hay una alternativa interesante. En onTouchEvent en cada progtwig ACTION_DOWN, se puede ejecutar Runnable en 1 segundo. En cada ACTION_UP o ACTION_MOVE , cancele Runnable progtwigdo. Si la cancelación ocurre a menos de 1s del evento ACTION_DOWN, Runnable no se ejecutará.

 final Handler handler = new Handler(); Runnable mLongPressed = new Runnable() { public void run() { Log.i("", "Long press!"); } }; @Override public boolean onTouchEvent(MotionEvent event, MapView mapView){ if(event.getAction() == MotionEvent.ACTION_DOWN) handler.postDelayed(mLongPressed, ViewConfiguration.getLongPressTimeout()); if((event.getAction() == MotionEvent.ACTION_MOVE)||(event.getAction() == MotionEvent.ACTION_UP)) handler.removeCallbacks(mLongPressed); return super.onTouchEvent(event, mapView); } 

Cuando te refieres a presiones de usuario, ¿te refieres a un clic? Un clic es cuando el usuario presiona hacia abajo y luego levanta el dedo inmediatamente. Por lo tanto, está abarcando dos eventos onTouch. Debería guardar el uso de On TouchEvent para las cosas que suceden en el toque inicial o posterior.

Por lo tanto, debe usar onClickListener si se trata de un clic.

Su respuesta es análoga: use onLongClickListener.

Tengo un código que detecta un clic, un clic largo y movimiento. Es bastante una combinación de la respuesta dada anteriormente y los cambios que hice de mirar furtivamente en cada página de documentación.

 //Declare this flag globally boolean goneFlag = false; //Put this into the class final Handler handler = new Handler(); Runnable mLongPressed = new Runnable() { public void run() { goneFlag = true; //Code for long click } }; //onTouch code @Override public boolean onTouch(View v, MotionEvent event) { switch (event.getAction()) { case MotionEvent.ACTION_DOWN: handler.postDelayed(mLongPressed, 1000); //This is where my code for movement is initialized to get original location. break; case MotionEvent.ACTION_UP: handler.removeCallbacks(mLongPressed); if(Math.abs(event.getRawX() - initialTouchX) <= 2 && !goneFlag) { //Code for single click return false; } break; case MotionEvent.ACTION_MOVE: handler.removeCallbacks(mLongPressed); //Code for movement here. This may include using a window manager to update the view break; } return true; } 

Confirmo que está funcionando como lo he usado en mi propia aplicación.

La solución de MSquare solo funciona si tiene un píxel específico, pero eso es una expectativa irrazonable para un usuario final, a menos que use un mouse (que no usan dedos).

Así que agregué un poco de un umbral para la distancia entre la acción ABAJO y ARRIBA en caso de que hubiera una acción de MOVIMIENTO en medio.

 final Handler longPressHandler = new Handler(); Runnable longPressedRunnable = new Runnable() { public void run() { Log.e(TAG, "Long press detected in long press Handler!"); isLongPressHandlerActivated = true; } }; private boolean isLongPressHandlerActivated = false; private boolean isActionMoveEventStored = false; private float lastActionMoveEventBeforeUpX; private float lastActionMoveEventBeforeUpY; @Override public boolean dispatchTouchEvent(MotionEvent event) { if(event.getAction() == MotionEvent.ACTION_DOWN) { longPressHandler.postDelayed(longPressedRunnable, 1000); } if(event.getAction() == MotionEvent.ACTION_MOVE || event.getAction() == MotionEvent.ACTION_HOVER_MOVE) { if(!isActionMoveEventStored) { isActionMoveEventStored = true; lastActionMoveEventBeforeUpX = event.getX(); lastActionMoveEventBeforeUpY = event.getY(); } else { float currentX = event.getX(); float currentY = event.getY(); float firstX = lastActionMoveEventBeforeUpX; float firstY = lastActionMoveEventBeforeUpY; double distance = Math.sqrt( (currentY - firstY) * (currentY - firstY) + ((currentX - firstX) * (currentX - firstX))); if(distance > 20) { longPressHandler.removeCallbacks(longPressedRunnable); } } } if(event.getAction() == MotionEvent.ACTION_UP) { isActionMoveEventStored = false; longPressHandler.removeCallbacks(longPressedRunnable); if(isLongPressHandlerActivated) { Log.d(TAG, "Long Press detected; halting propagation of motion event"); isLongPressHandlerActivated = false; return false; } } return super.dispatchTouchEvent(event); } 

La idea es crear un Runnable para ejecutar un clic largo en un futuro, pero esta ejecución se puede cancelar debido a un clic o movimiento.

También debe saber cuándo se consumió un clic prolongado y cuándo se cancela porque el dedo se movió demasiado. Usamos initialTouchX y initialTouchY para verificar si el usuario sale de un área cuadrada de 10 píxeles, 5 en cada lado.

Aquí está mi código completo para delegar Click & LongClick desde Cell en ListView a Activity con OnTouchListener :

  ClickDelegate delegate; boolean goneFlag = false; float initialTouchX; float initialTouchY; final Handler handler = new Handler(); Runnable mLongPressed = new Runnable() { public void run() { Log.i("TOUCH_EVENT", "Long press!"); if (delegate != null) { goneFlag = delegate.onItemLongClick(index); } else { goneFlag = true; } } }; @OnTouch({R.id.layout}) public boolean onTouch (View view, MotionEvent motionEvent) { switch (motionEvent.getAction()) { case MotionEvent.ACTION_DOWN: handler.postDelayed(mLongPressed, ViewConfiguration.getLongPressTimeout()); initialTouchX = motionEvent.getRawX(); initialTouchY = motionEvent.getRawY(); return true; case MotionEvent.ACTION_MOVE: case MotionEvent.ACTION_CANCEL: if (Math.abs(motionEvent.getRawX() - initialTouchX) > 5 || Math.abs(motionEvent.getRawY() - initialTouchY) > 5) { handler.removeCallbacks(mLongPressed); return true; } return false; case MotionEvent.ACTION_UP: handler.removeCallbacks(mLongPressed); if (goneFlag || Math.abs(motionEvent.getRawX() - initialTouchX) > 5 || Math.abs(motionEvent.getRawY() - initialTouchY) > 5) { goneFlag = false; return true; } break; } Log.i("TOUCH_EVENT", "Short press!"); if (delegate != null) { if (delegate.onItemClick(index)) { return false; } } return false; } 

ClickDelegate es una interface para enviar eventos de clic a la clase de controlador como una Activity

  public interface ClickDelegate { boolean onItemClick(int position); boolean onItemLongClick(int position); } 

Y todo lo que necesita es implementarlo en su Activity o View principal si necesita delegar el comportamiento:

 public class MyActivity extends Activity implements ClickDelegate { //code... //in some place of you code like onCreate, //you need to set the delegate like this: SomeArrayAdapter.delegate = this; //or: SomeViewHolder.delegate = this; //or: SomeCustomView.delegate = this; @Override public boolean onItemClick(int position) { Object obj = list.get(position); if (obj) { return true; //if you handle click } else { return false; //if not, it could be another event } } @Override public boolean onItemLongClick(int position) { Object obj = list.get(position); if (obj) { return true; //if you handle long click } else { return false; //if not, it's a click } } } 
 setOnTouchListener(new View.OnTouchListener() { public boolean onTouch(View v, MotionEvent event) { int action = MotionEventCompat.getActionMasked(event); switch (event.getAction()) { case MotionEvent.ACTION_DOWN: longClick = false; x1 = event.getX(); break; case MotionEvent.ACTION_MOVE: if (event.getEventTime() - event.getDownTime() > 500 && Math.abs(event.getX() - x1) < MIN_DISTANCE) { longClick = true; } break; case MotionEvent.ACTION_UP: if (longClick) { Toast.makeText(activity, "Long preess", Toast.LENGTH_SHORT).show(); } } return true; } }); 

He creado un fragmento , inspirado en la fuente de la vista real, que detecta de manera confiable los clics largos / pulsaciones con un retraso personalizado. Pero está en Kotlin:

 val LONG_PRESS_DELAY = 500 val handler = Handler() var boundaries: Rect? = null var onTap = Runnable { handler.postDelayed(onLongPress, LONG_PRESS_DELAY - ViewConfiguration.getTapTimeout().toLong()) } var onLongPress = Runnable { // Long Press } override fun onTouch(view: View, event: MotionEvent): Boolean { when (event.action) { MotionEvent.ACTION_DOWN -> { boundaries = Rect(view.left, view.top, view.right, view.bottom) handler.postDelayed(onTap, ViewConfiguration.getTapTimeout().toLong()) } MotionEvent.ACTION_UP, MotionEvent.ACTION_CANCEL -> { handler.removeCallbacks(onLongPress) handler.removeCallbacks(onTap) } MotionEvent.ACTION_MOVE -> { if (!boundaries!!.contains(view.left + event.x.toInt(), view.top + event.y.toInt())) { handler.removeCallbacks(onLongPress) handler.removeCallbacks(onTap) } } } return true }