Un gesto di tocco si verifica quando un utente posiziona una o più dita sul touchscreen e la tua app interpreta questo modello di tocco come un gesto. Il rilevamento dei gesti prevede due fasi:
- Raccolta di dati sugli eventi touch.
- Interpretare i dati per determinare se soddisfano i criteri per i gesti supportati dalla tua app.
Classi AndroidX
Gli esempi in questo documento utilizzano le classi
GestureDetectorCompat
e
MotionEventCompat
. Queste classi si trovano nella libreria
AndroidX. Se possibile, utilizza le classi AndroidX per garantire la compatibilità con i dispositivi precedenti.
MotionEventCompat
non sostituisce la classe
MotionEvent
. Fornisce invece metodi di utilità statici a cui passi l'oggetto MotionEvent
per ricevere l'azione associata all'evento.
Raccogli i dati
Quando un utente posiziona una o più dita sullo schermo, viene attivato il
callback
onTouchEvent()
sulla visualizzazione che riceve gli eventi touch. Per ogni sequenza di eventi
tocco, come posizione, pressione, dimensione e aggiunta di un altro
dito, identificata come un gesto, onTouchEvent()
viene
attivato più volte.
Il gesto inizia quando l'utente tocca per la prima volta lo schermo, continua mentre il sistema rileva la posizione del dito o delle dita dell'utente e termina con l'acquisizione dell'evento finale dell'ultimo dito dell'utente che ha lasciato lo schermo.
Nel corso di questa interazione, il MotionEvent
inviato a
onTouchEvent()
fornisce i dettagli di ogni interazione. La tua app
può utilizzare i dati forniti da MotionEvent
per determinare se avviene un
gesto che gli interessa.
Acquisire eventi tocco per un'attività o una vista
Per intercettare gli eventi touch in un Activity
o
View
, sostituisci il callback onTouchEvent()
.
Il seguente snippet di codice utilizza getAction()
per estrarre l'azione eseguita dall'utente dal parametro event
.
In questo modo ottieni i dati non elaborati necessari per determinare se si verifica un gesto che ti interessa.
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); } }
Questo codice produce messaggi come il seguente in Logcat quando l'utente tocca, tocca, tiene premuto e trascina:
GESTURES D Action was DOWN GESTURES D Action was UP GESTURES D Action was MOVE
Per i gesti personalizzati, puoi quindi elaborare questi eventi in autonomia per determinare se rappresentano un gesto che devi gestire. Tuttavia, se la tua app utilizza gesti comuni, come doppio tocco, tocco e pressione, scorrimento e così via, puoi usufruire della lezione GestureDetector
. GestureDetector
ti consente di rilevare più facilmente i gesti
comuni senza elaborare personalmente i singoli eventi di tocco. Questo argomento viene
trattato più in dettaglio in Rileva gesti.
Acquisizione di eventi touch per un'unica visualizzazione
In alternativa a onTouchEvent()
, puoi collegare un oggetto View.OnTouchListener
a qualsiasi oggetto View
utilizzando il metodo setOnTouchListener()
. In questo modo è possibile rimanere in ascolto di eventi touch senza creare sottoclassi di un
View
esistente, come mostrato nell'esempio seguente:
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; } });
Presta attenzione alla creazione di un listener che restituisca false
per
l'evento ACTION_DOWN
.
In questo caso, il listener non viene chiamato per la sequenza
di eventi ACTION_MOVE
e
ACTION_UP
successiva. Questo perché ACTION_DOWN
è il punto di partenza per tutti
gli eventi touch.
Se stai creando una vista personalizzata, puoi eseguire l'override di onTouchEvent()
, come descritto in precedenza.
Rileva gesti
Android fornisce la classe GestureDetector
per il rilevamento
dei gesti più comuni. Tra i gesti supportati ci sono
onDown()
,
onLongPress()
e
onFling()
.
Puoi utilizzare GestureDetector
insieme al
metodo onTouchEvent()
descritto in precedenza.
Rileva tutti i gesti supportati
Quando crei un'istanza per un oggetto GestureDetectorCompat
, uno dei parametri necessari è una classe che implementa l'interfaccia GestureDetector.OnGestureListener
. GestureDetector.OnGestureListener
invia una notifica agli utenti quando
si verifica un particolare evento tocco. Per consentire all'oggetto GestureDetector
di ricevere eventi, sostituisci il metodo onTouchEvent()
della vista o dell'attività e trasmetti tutti gli eventi osservati all'istanza del rilevatore.
Nel seguente snippet, un valore restituito true
dai singoli metodi on<TouchEvent>
indica che l'evento tocco viene gestito. Un valore restituito false
passa gli eventi attraverso
l'elenco di visualizzazioni finché il tocco non viene gestito correttamente.
Se esegui il seguente snippet in un'app di prova, puoi farti un'idea di come vengono attivate le azioni quando interagisci con il touchscreen e di quali sono i contenuti dell'elemento MotionEvent
per ogni evento touch. Puoi vedere quanti dati vengono generati
per le interazioni semplici.
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; } }
Rileva un sottoinsieme di gesti supportati
Se vuoi elaborare solo pochi gesti, puoi estendere GestureDetector.SimpleOnGestureListener
anziché implementare l'interfaccia GestureDetector.OnGestureListener
.
GestureDetector.SimpleOnGestureListener
fornisce
un'implementazione per tutti i
metodi di on<TouchEvent>
restituendo
false
per tutti. In questo modo puoi ignorare solo
i metodi che ti interessano. Ad esempio, il seguente snippet di codice crea una classe che estende
GestureDetector.SimpleOnGestureListener
e sostituisce
onFling()
e onDown()
.
Sia che utilizzi GestureDetector.OnGestureListener
o
GestureDetector.SimpleOnGestureListener
, una best practice prevede l'implementazione di un metodo onDown()
che restituisca true
. Questo
perché tutti i gesti iniziano con un messaggio onDown()
. Se
restituisci false
da onDown()
, come fa
GestureDetector.SimpleOnGestureListener
per impostazione predefinita, il sistema presuppone che tu voglia ignorare il resto del gesto e gli altri metodi di
GestureDetector.OnGestureListener
non vengono chiamati. Questo potrebbe causare
problemi imprevisti nella tua app. Restituisci false
solo da
onDown()
se vuoi davvero ignorare un intero gesto.
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; } } }
Risorse aggiuntive
- Panoramica degli eventi di input
- Panoramica dei sensori
- Rendere interattiva una visualizzazione personalizzata