Um gesto de toque ocorre quando um usuário coloca um ou mais dedos na tela touchscreen e o app interpreta esse padrão de toques como um gesto. Há duas fases na detecção de gestos:
- Coletando dados de eventos de toque.
- Interpretar os dados para determinar se eles atendem aos critérios de gestos compatíveis com seu app.
Classes do AndroidX
Os exemplos neste documento usam as classes
GestureDetectorCompat
e
MotionEventCompat
. Essas classes estão na Biblioteca
AndroidX. Use as classes do AndroidX sempre que possível para oferecer compatibilidade com
dispositivos anteriores.
MotionEventCompat
não substitui a
classe
MotionEvent
. Em vez disso, ele oferece métodos utilitários estáticos para os quais você transmite o objeto
MotionEvent
para receber a ação associada a esse
evento.
Colete dados
Quando um usuário coloca um ou mais dedos na tela, isso aciona o
onTouchEvent()
de callback
na visualização que recebe os eventos de toque. Para cada sequência de eventos de toque,
como posição, pressão, tamanho e adição de outro
dedo, identificada como um gesto, onTouchEvent()
é
disparado várias vezes.
O gesto começa quando o usuário toca na tela pela primeira vez, continua enquanto o
sistema rastreia a posição desses dedos e termina
capturando o evento final do último dedo que sai da tela.
Durante essa interação, o MotionEvent
entregue ao
onTouchEvent()
fornece os detalhes de cada interação. Seu app
pode usar os dados fornecidos pelo MotionEvent
para determinar se um
gesto é importante para ele.
Capturar eventos de toque para uma atividade ou visualização
Para interceptar eventos de toque em uma Activity
ou
View
, substitua o callback onTouchEvent()
.
O snippet de código a seguir usa
getAction()
para extrair a ação que o usuário realiza do parâmetro event
.
Isso fornece os dados brutos necessários para determinar se ocorre um gesto
importante para você.
Kotlin
class MainActivity : Activity() { ... // This example shows an Activity. You can use the same approach if you are // subclassing a View. override fun onTouchEvent(event: MotionEvent): Boolean { return when (event.action) { MotionEvent.ACTION_DOWN -> { Log.d(DEBUG_TAG, "Action was DOWN") true } MotionEvent.ACTION_MOVE -> { Log.d(DEBUG_TAG, "Action was MOVE") true } MotionEvent.ACTION_UP -> { Log.d(DEBUG_TAG, "Action was UP") true } MotionEvent.ACTION_CANCEL -> { Log.d(DEBUG_TAG, "Action was CANCEL") true } MotionEvent.ACTION_OUTSIDE -> { Log.d(DEBUG_TAG, "Movement occurred outside bounds of current screen element") true } else -> super.onTouchEvent(event) } } }
Java
public class MainActivity extends Activity { ... // This example shows an Activity. You can use the same approach if you are // subclassing a View. @Override public boolean onTouchEvent(MotionEvent event){ switch(event.getAction()) { case (MotionEvent.ACTION_DOWN) : Log.d(DEBUG_TAG,"Action was DOWN"); return true; case (MotionEvent.ACTION_MOVE) : Log.d(DEBUG_TAG,"Action was MOVE"); return true; case (MotionEvent.ACTION_UP) : Log.d(DEBUG_TAG,"Action was UP"); return true; case (MotionEvent.ACTION_CANCEL) : Log.d(DEBUG_TAG,"Action was CANCEL"); return true; case (MotionEvent.ACTION_OUTSIDE) : Log.d(DEBUG_TAG,"Movement occurred outside bounds of current screen element"); return true; default : return super.onTouchEvent(event); } }
Esse código produz mensagens como as seguintes no Logcat, quando o usuário toca, toca, segura e arrasta:
GESTURES D Action was DOWN GESTURES D Action was UP GESTURES D Action was MOVE
No caso de gestos personalizados, você pode fazer seu próprio processamento nesses eventos para
determinar se eles representam um gesto que precisa ser processado. No entanto, se o
app usa gestos comuns, como tocar duas vezes, manter pressionado, movimentar etc.,
você pode usar a
classe
GestureDetector
. GestureDetector
facilita a detecção de gestos
comuns sem que você precise processar os eventos de toque individuais por conta própria. Isso é
discutido com mais detalhes em Detectar gestos.
Capturar eventos de toque para uma visualização única
Como alternativa a onTouchEvent()
, você pode anexar um objeto
View.OnTouchListener
a qualquer objeto View
usando o
método
setOnTouchListener()
. Isso possibilita detectar eventos de toque sem subclassificar um
View
existente, conforme mostrado neste exemplo:
Kotlin
findViewById<View>(R.id.my_view).setOnTouchListener { v, event -> // Respond to touch events. true }
Java
View myView = findViewById(R.id.my_view); myView.setOnTouchListener(new OnTouchListener() { public boolean onTouch(View v, MotionEvent event) { // Respond to touch events. return true; } });
Cuidado ao criar um listener que retorne false
para o
evento ACTION_DOWN
.
Se você fizer isso, o listener não será chamado para a sequência
ACTION_MOVE
e
ACTION_UP
subsequente dos
eventos. Isso ocorre porque ACTION_DOWN
é o ponto de partida para todos
os eventos de toque.
Se você estiver criando uma visualização personalizada, poderá substituir
onTouchEvent()
, conforme descrito anteriormente.
Detectar gestos
O Android oferece a classe GestureDetector
para detectar gestos
comuns. Alguns dos gestos compatíveis incluem
onDown()
,
onLongPress()
e
onFling()
.
Você pode usar GestureDetector
com o
método onTouchEvent()
descrito anteriormente.
Detectar todos os gestos compatíveis
Quando você instancia um objeto GestureDetectorCompat
, um dos
parâmetros necessários é uma classe que implementa a
interface
GestureDetector.OnGestureListener
. GestureDetector.OnGestureListener
notifica os usuários quando
um evento de toque específico ocorre. Para que o objeto
GestureDetector
receba eventos, modifique o método onTouchEvent()
da visualização ou
da atividade e transmita todos os eventos observados
para a instância do detector.
No snippet a seguir, um valor de retorno de true
dos
métodos on<TouchEvent>
individuais indica que o
evento de toque foi processado. Um valor de retorno false
transmite eventos
pela pilha de visualização até que o toque seja processado.
Se você executar o snippet a seguir em um app de teste, poderá ter uma noção de como
as ações são acionadas quando você interage com a tela e qual é o
conteúdo de MotionEvent
para cada evento de toque. Você verá
quantos dados estão sendo gerados para interações simples.
Kotlin
private const val DEBUG_TAG = "Gestures" class MainActivity : Activity(), GestureDetector.OnGestureListener, GestureDetector.OnDoubleTapListener { private lateinit var mDetector: GestureDetectorCompat // Called when the activity is first created. public override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) setContentView(R.layout.activity_main) // Instantiate the gesture detector with the // application context and an implementation of // GestureDetector.OnGestureListener. mDetector = GestureDetectorCompat(this, this) // Set the gesture detector as the double-tap // listener. mDetector.setOnDoubleTapListener(this) } override fun onTouchEvent(event: MotionEvent): Boolean { return if (mDetector.onTouchEvent(event)) { true } else { super.onTouchEvent(event) } } override fun onDown(event: MotionEvent): Boolean { Log.d(DEBUG_TAG, "onDown: $event") return true } override fun onFling( event1: MotionEvent, event2: MotionEvent, velocityX: Float, velocityY: Float ): Boolean { Log.d(DEBUG_TAG, "onFling: $event1 $event2") return true } override fun onLongPress(event: MotionEvent) { Log.d(DEBUG_TAG, "onLongPress: $event") } override fun onScroll( event1: MotionEvent, event2: MotionEvent, distanceX: Float, distanceY: Float ): Boolean { Log.d(DEBUG_TAG, "onScroll: $event1 $event2") return true } override fun onShowPress(event: MotionEvent) { Log.d(DEBUG_TAG, "onShowPress: $event") } override fun onSingleTapUp(event: MotionEvent): Boolean { Log.d(DEBUG_TAG, "onSingleTapUp: $event") return true } override fun onDoubleTap(event: MotionEvent): Boolean { Log.d(DEBUG_TAG, "onDoubleTap: $event") return true } override fun onDoubleTapEvent(event: MotionEvent): Boolean { Log.d(DEBUG_TAG, "onDoubleTapEvent: $event") return true } override fun onSingleTapConfirmed(event: MotionEvent): Boolean { Log.d(DEBUG_TAG, "onSingleTapConfirmed: $event") return true } }
Java
public class MainActivity extends Activity implements GestureDetector.OnGestureListener, GestureDetector.OnDoubleTapListener{ private static final String DEBUG_TAG = "Gestures"; private GestureDetectorCompat mDetector; // Called when the activity is first created. @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); // Instantiate the gesture detector with the // application context and an implementation of // GestureDetector.OnGestureListener. mDetector = new GestureDetectorCompat(this,this); // Set the gesture detector as the double-tap // listener. mDetector.setOnDoubleTapListener(this); } @Override public boolean onTouchEvent(MotionEvent event){ if (this.mDetector.onTouchEvent(event)) { return true; } return super.onTouchEvent(event); } @Override public boolean onDown(MotionEvent event) { Log.d(DEBUG_TAG,"onDown: " + event.toString()); return true; } @Override public boolean onFling(MotionEvent event1, MotionEvent event2, float velocityX, float velocityY) { Log.d(DEBUG_TAG, "onFling: " + event1.toString() + event2.toString()); return true; } @Override public void onLongPress(MotionEvent event) { Log.d(DEBUG_TAG, "onLongPress: " + event.toString()); } @Override public boolean onScroll(MotionEvent event1, MotionEvent event2, float distanceX, float distanceY) { Log.d(DEBUG_TAG, "onScroll: " + event1.toString() + event2.toString()); return true; } @Override public void onShowPress(MotionEvent event) { Log.d(DEBUG_TAG, "onShowPress: " + event.toString()); } @Override public boolean onSingleTapUp(MotionEvent event) { Log.d(DEBUG_TAG, "onSingleTapUp: " + event.toString()); return true; } @Override public boolean onDoubleTap(MotionEvent event) { Log.d(DEBUG_TAG, "onDoubleTap: " + event.toString()); return true; } @Override public boolean onDoubleTapEvent(MotionEvent event) { Log.d(DEBUG_TAG, "onDoubleTapEvent: " + event.toString()); return true; } @Override public boolean onSingleTapConfirmed(MotionEvent event) { Log.d(DEBUG_TAG, "onSingleTapConfirmed: " + event.toString()); return true; } }
Detectar um subconjunto de gestos compatíveis
Se você quer processar apenas alguns gestos, pode estender
GestureDetector.SimpleOnGestureListener
em vez de implementar a interface
GestureDetector.OnGestureListener
.
GestureDetector.SimpleOnGestureListener
fornece uma
implementação para todos os métodos
on<TouchEvent>
retornando
false
para todos eles. Isso permite substituir apenas os métodos
que são importantes para você. Por exemplo, o snippet de código abaixo cria uma classe que estende
GestureDetector.SimpleOnGestureListener
e substitui
onFling()
e onDown()
.
Se você usar GestureDetector.OnGestureListener
ou
GestureDetector.SimpleOnGestureListener
, uma prática recomendada é
implementar um método onDown()
que retorne true
. Isso
acontece porque todos os gestos começam com uma mensagem onDown()
. Se você
retornar false
de onDown()
, como
GestureDetector.SimpleOnGestureListener
faz por padrão, o sistema
supõe que você quer ignorar o restante do gesto, e os outros métodos de
GestureDetector.OnGestureListener
não são chamados. Isso pode causar
problemas inesperados no app. Só retorne false
de
onDown()
se você realmente quiser ignorar um gesto inteiro.
Kotlin
private const val DEBUG_TAG = "Gestures" class MainActivity : Activity() { private lateinit var mDetector: GestureDetectorCompat public override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) setContentView(R.layout.activity_main) mDetector = GestureDetectorCompat(this, MyGestureListener()) } override fun onTouchEvent(event: MotionEvent): Boolean { mDetector.onTouchEvent(event) return super.onTouchEvent(event) } private class MyGestureListener : GestureDetector.SimpleOnGestureListener() { override fun onDown(event: MotionEvent): Boolean { Log.d(DEBUG_TAG, "onDown: $event") return true } override fun onFling( event1: MotionEvent, event2: MotionEvent, velocityX: Float, velocityY: Float ): Boolean { Log.d(DEBUG_TAG, "onFling: $event1 $event2") return true } } }
Java
public class MainActivity extends Activity { private GestureDetectorCompat mDetector; @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); mDetector = new GestureDetectorCompat(this, new MyGestureListener()); } @Override public boolean onTouchEvent(MotionEvent event){ if (this.mDetector.onTouchEvent(event)) { return true; } return super.onTouchEvent(event); } class MyGestureListener extends GestureDetector.SimpleOnGestureListener { private static final String DEBUG_TAG = "Gestures"; @Override public boolean onDown(MotionEvent event) { Log.d(DEBUG_TAG,"onDown: " + event.toString()); return true; } @Override public boolean onFling(MotionEvent event1, MotionEvent event2, float velocityX, float velocityY) { Log.d(DEBUG_TAG, "onFling: " + event1.toString() + event2.toString()); return true; } } }
Outros recursos
- Visão geral dos eventos de entrada
- Visão geral dos sensores
- Tornar uma visualização personalizada interativa