In Android, in genere lo scorrimento si ottiene utilizzando la classe ScrollView
. Nidifica qualsiasi layout standard che potrebbe estendersi oltre i limiti del
contenitore in un elemento ScrollView
per fornire una visualizzazione scorrevole gestita
dal framework. L'implementazione di uno scorrimento personalizzato è necessaria solo
per scenari speciali. Questo documento descrive come visualizzare un effetto di scorrimento in risposta ai gesti tattili utilizzando gli scorrimenti.
L'app può usare
gli scorrimenti (Scroller
o
OverScroller
) per
raccogliere i dati necessari per produrre un'animazione di scorrimento in risposta a un
evento touch. Sono simili, ma OverScroller
include anche metodi per
indicare agli utenti quando raggiungono i bordi dei contenuti dopo una panoramica
o un gesto di scorrimento.
- A partire da Android 12 (livello API 31), gli elementi visivi si allungano e si rimbalzano durante un evento di trascinamento, per poi rimbalzare e rimbalzare durante un evento fling.
- Su Android 11 (livello API 30) e versioni precedenti, i confini mostrano un effetto "bagliore" dopo un gesto di trascinamento o scorrimento verso il bordo.
L'esempio InteractiveChart
in questo documento utilizza la classe EdgeEffect
per visualizzare questi effetti overscroll.
Puoi utilizzare uno scorrimento per animare lo scorrimento nel tempo, utilizzando le fisiche dello scorrimento standard della piattaforma, come l'attrito, la velocità e altre qualità. Lo scorrimento in sé non disegna nulla. Gli strumenti di scorrimento tengono traccia degli offset di scorrimento nel tempo, ma non applicano automaticamente queste posizioni alla visualizzazione. Devi ottenere e applicare le nuove coordinate a una velocità tale da rendere l'animazione a scorrimento uniforme.
Comprendere la terminologia relativa allo scorrimento
"Scorrimento" è una parola che può assumere significati diversi in Android, a seconda del contesto.
Lo scorrimento è la procedura generale di spostamento dell'area visibile, ovvero la"finestra" dei contenuti visualizzati. Quando lo scorrimento è sull'asse x e y, si parla di panning. L'app
di esempio InteractiveChart
in questo documento illustra due
diversi tipi di scorrimento, trascinamento e scorrimento:
- Trascinamento: è il tipo di scorrimento che si verifica quando un utente trascina il dito sul touchscreen. Puoi implementare il trascinamento
eseguendo l'override di
onScroll()
inGestureDetector.OnGestureListener
. Per maggiori informazioni sul trascinamento, vedi Trascinamento e scalabilità. - Fling: è il tipo di scorrimento che si verifica quando un utente trascina e solleva rapidamente il dito. Dopo che l'utente ha sollevato il dito, in genere si vuole continuare a spostare l'area visibile, ma la si rallenta finché l'area visibile non si sposta. Puoi implementare il fling eseguendo l'override di
onFling()
inGestureDetector.OnGestureListener
e utilizzando un oggetto di scorrimento. - Panning: lo scorrimento simultaneo su entrambi gli assi x e y prende il nome di panning.
È comune utilizzare oggetti scorrimento in combinazione con un gesto flesso, ma puoi utilizzarli in qualsiasi contesto in cui desideri che l'UI mostri lo scorrimento in risposta a un evento tocco. Ad esempio, puoi eseguire l'override di
onTouchEvent()
per elaborare direttamente gli eventi tocco e produrre un effetto di scorrimento o un'animazione
"snap-to-page" in risposta a questi eventi di tocco.
Componenti che contengono implementazioni di scorrimento integrate
I seguenti componenti Android contengono il supporto integrato per il comportamento di scorrimento e sovrapposizione:
GridView
HorizontalScrollView
ListView
NestedScrollView
RecyclerView
ScrollView
ViewPager
ViewPager2
Se la tua app deve supportare lo scorrimento e lo scorrimento superiore all'interno di un componente diverso, completa i seguenti passaggi:
- Crea un'implementazione di scorrimento personalizzata basata sul tocco.
- Per supportare i dispositivi con Android 12 e versioni successive, implementa l'effetto overscroll.
Creare un'implementazione di scorrimento personalizzata basata sul tocco
Questa sezione descrive come creare uno scorrimento personalizzato se l'app utilizza un componente che non contiene il supporto integrato per lo scorrimento e l'overscroll.
Il seguente snippet proviene dall'esempio
InteractiveChart
. Utilizza un
GestureDetector
e sostituisce il
metodo GestureDetector.SimpleOnGestureListener
onFling()
. Usa OverScroller
per tenere traccia
del gesto flesso. Se l'utente raggiunge i bordi dei contenuti dopo aver eseguito il gesto flesso, il contenitore indica quando l'utente raggiunge la fine dei contenuti. L'indicazione dipende dalla versione di Android
in esecuzione su un dispositivo:
- Su Android 12 e versioni successive, gli elementi visivi si allungano e tornano indietro.
- Su Android 11 e versioni precedenti, gli elementi visivi mostrano un effetto di incandescenza.
La prima parte del seguente snippet mostra l'implementazione di
onFling()
:
Kotlin
// Viewport extremes. See currentViewport for a discussion of the viewport. private val AXIS_X_MIN = -1f private val AXIS_X_MAX = 1f private val AXIS_Y_MIN = -1f private val AXIS_Y_MAX = 1f // The current viewport. This rectangle represents the visible chart // domain and range. The viewport is the part of the app that the // user manipulates via touch gestures. private val currentViewport = RectF(AXIS_X_MIN, AXIS_Y_MIN, AXIS_X_MAX, AXIS_Y_MAX) // The current destination rectangle—in pixel coordinates—into which // the chart data must be drawn. private lateinit var contentRect: Rect private lateinit var scroller: OverScroller private lateinit var scrollerStartViewport: RectF ... private val gestureListener = object : GestureDetector.SimpleOnGestureListener() { override fun onDown(e: MotionEvent): Boolean { // Initiates the decay phase of any active edge effects. if (Build.VERSION.SDK_INT < Build.VERSION_CODES.S) { releaseEdgeEffects() } scrollerStartViewport.set(currentViewport) // Aborts any active scroll animations and invalidates. scroller.forceFinished(true) ViewCompat.postInvalidateOnAnimation(this@InteractiveLineGraphView) return true } ... override fun onFling( e1: MotionEvent, e2: MotionEvent, velocityX: Float, velocityY: Float ): Boolean { fling((-velocityX).toInt(), (-velocityY).toInt()) return true } } private fun fling(velocityX: Int, velocityY: Int) { // Initiates the decay phase of any active edge effects. // On Android 12 and later, the edge effect (stretch) must // continue. if (Build.VERSION.SDK_INT < Build.VERSION_CODES.S) { releaseEdgeEffects() } // Flings use math in pixels, as opposed to math based on the viewport. val surfaceSize: Point = computeScrollSurfaceSize() val (startX: Int, startY: Int) = scrollerStartViewport.run { set(currentViewport) (surfaceSize.x * (left - AXIS_X_MIN) / (AXIS_X_MAX - AXIS_X_MIN)).toInt() to (surfaceSize.y * (AXIS_Y_MAX - bottom) / (AXIS_Y_MAX - AXIS_Y_MIN)).toInt() } // Before flinging, stops the current animation. scroller.forceFinished(true) // Begins the animation. scroller.fling( // Current scroll position. startX, startY, velocityX, velocityY, /* * Minimum and maximum scroll positions. The minimum scroll * position is generally 0 and the maximum scroll position * is generally the content size less the screen size. So if the * content width is 1000 pixels and the screen width is 200 * pixels, the maximum scroll offset is 800 pixels. */ 0, surfaceSize.x - contentRect.width(), 0, surfaceSize.y - contentRect.height(), // The edges of the content. This comes into play when using // the EdgeEffect class to draw "glow" overlays. contentRect.width() / 2, contentRect.height() / 2 ) // Invalidates to trigger computeScroll(). ViewCompat.postInvalidateOnAnimation(this) }
Java
// Viewport extremes. See currentViewport for a discussion of the viewport. private static final float AXIS_X_MIN = -1f; private static final float AXIS_X_MAX = 1f; private static final float AXIS_Y_MIN = -1f; private static final float AXIS_Y_MAX = 1f; // The current viewport. This rectangle represents the visible chart // domain and range. The viewport is the part of the app that the // user manipulates via touch gestures. private RectF currentViewport = new RectF(AXIS_X_MIN, AXIS_Y_MIN, AXIS_X_MAX, AXIS_Y_MAX); // The current destination rectangle—in pixel coordinates—into which // the chart data must be drawn. private final Rect contentRect = new Rect(); private final OverScroller scroller; private final RectF scrollerStartViewport = new RectF(); // Used only for zooms and flings. ... private final GestureDetector.SimpleOnGestureListener gestureListener = new GestureDetector.SimpleOnGestureListener() { @Override public boolean onDown(MotionEvent e) { if (Build.VERSION.SDK_INT < Build.VERSION_CODES.S) { releaseEdgeEffects(); } scrollerStartViewport.set(currentViewport); scroller.forceFinished(true); ViewCompat.postInvalidateOnAnimation(InteractiveLineGraphView.this); return true; } ... @Override public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) { fling((int) -velocityX, (int) -velocityY); return true; } }; private void fling(int velocityX, int velocityY) { // Initiates the decay phase of any active edge effects. // On Android 12 and later, the edge effect (stretch) must // continue. if (Build.VERSION.SDK_INT < Build.VERSION_CODES.S) { releaseEdgeEffects(); } // Flings use math in pixels, as opposed to math based on the viewport. Point surfaceSize = computeScrollSurfaceSize(); scrollerStartViewport.set(currentViewport); int startX = (int) (surfaceSize.x * (scrollerStartViewport.left - AXIS_X_MIN) / ( AXIS_X_MAX - AXIS_X_MIN)); int startY = (int) (surfaceSize.y * (AXIS_Y_MAX - scrollerStartViewport.bottom) / ( AXIS_Y_MAX - AXIS_Y_MIN)); // Before flinging, stops the current animation. scroller.forceFinished(true); // Begins the animation. scroller.fling( // Current scroll position. startX, startY, velocityX, velocityY, /* * Minimum and maximum scroll positions. The minimum scroll * position is generally 0 and the maximum scroll position * is generally the content size less the screen size. So if the * content width is 1000 pixels and the screen width is 200 * pixels, the maximum scroll offset is 800 pixels. */ 0, surfaceSize.x - contentRect.width(), 0, surfaceSize.y - contentRect.height(), // The edges of the content. This comes into play when using // the EdgeEffect class to draw "glow" overlays. contentRect.width() / 2, contentRect.height() / 2); // Invalidates to trigger computeScroll(). ViewCompat.postInvalidateOnAnimation(this); }
Quando onFling()
chiama
postInvalidateOnAnimation()
,
attiva l'aggiornamento
computeScroll()
dei valori per x e y. In genere, questo avviene quando una vista secondaria anima uno scorrimento utilizzando un oggetto scorrevole, come mostrato nell'esempio precedente.
La maggior parte delle visualizzazioni trasmette la posizione x e y dell'oggetto scorrimento direttamente
a
scrollTo()
.
La seguente implementazione di computeScroll()
adotta un approccio diverso: chiama computeScrollOffset()
per ottenere la posizione attuale di x e y. Quando vengono soddisfatti i criteri per
visualizzare un effetto di bordo "bagliore" overscroll, ovvero se viene aumentato lo zoom della visualizzazione, x o y supera i limiti e l'app non mostra già
un effetto di bagliore overscroll, il codice configura l'effetto di bagliore overscroll e
chiama postInvalidateOnAnimation()
per attivare un'annullamento sulla
vista.
Kotlin
// Edge effect/overscroll tracking objects. private lateinit var edgeEffectTop: EdgeEffect private lateinit var edgeEffectBottom: EdgeEffect private lateinit var edgeEffectLeft: EdgeEffect private lateinit var edgeEffectRight: EdgeEffect private var edgeEffectTopActive: Boolean = false private var edgeEffectBottomActive: Boolean = false private var edgeEffectLeftActive: Boolean = false private var edgeEffectRightActive: Boolean = false override fun computeScroll() { super.computeScroll() var needsInvalidate = false // The scroller isn't finished, meaning a fling or // programmatic pan operation is active. if (scroller.computeScrollOffset()) { val surfaceSize: Point = computeScrollSurfaceSize() val currX: Int = scroller.currX val currY: Int = scroller.currY val (canScrollX: Boolean, canScrollY: Boolean) = currentViewport.run { (left > AXIS_X_MIN || right < AXIS_X_MAX) to (top > AXIS_Y_MIN || bottom < AXIS_Y_MAX) } /* * If you are zoomed in, currX or currY is * outside of bounds, and you aren't already * showing overscroll, then render the overscroll * glow edge effect. */ if (canScrollX && currX < 0 && edgeEffectLeft.isFinished && !edgeEffectLeftActive) { edgeEffectLeft.onAbsorb(scroller.currVelocity.toInt()) edgeEffectLeftActive = true needsInvalidate = true } else if (canScrollX && currX > surfaceSize.x - contentRect.width() && edgeEffectRight.isFinished && !edgeEffectRightActive) { edgeEffectRight.onAbsorb(scroller.currVelocity.toInt()) edgeEffectRightActive = true needsInvalidate = true } if (canScrollY && currY < 0 && edgeEffectTop.isFinished && !edgeEffectTopActive) { edgeEffectTop.onAbsorb(scroller.currVelocity.toInt()) edgeEffectTopActive = true needsInvalidate = true } else if (canScrollY && currY > surfaceSize.y - contentRect.height() && edgeEffectBottom.isFinished && !edgeEffectBottomActive) { edgeEffectBottom.onAbsorb(scroller.currVelocity.toInt()) edgeEffectBottomActive = true needsInvalidate = true } ... } }
Java
// Edge effect/overscroll tracking objects. private EdgeEffectCompat edgeEffectTop; private EdgeEffectCompat edgeEffectBottom; private EdgeEffectCompat edgeEffectLeft; private EdgeEffectCompat edgeEffectRight; private boolean edgeEffectTopActive; private boolean edgeEffectBottomActive; private boolean edgeEffectLeftActive; private boolean edgeEffectRightActive; @Override public void computeScroll() { super.computeScroll(); boolean needsInvalidate = false; // The scroller isn't finished, meaning a fling or // programmatic pan operation is active. if (scroller.computeScrollOffset()) { Point surfaceSize = computeScrollSurfaceSize(); int currX = scroller.getCurrX(); int currY = scroller.getCurrY(); boolean canScrollX = (currentViewport.left > AXIS_X_MIN || currentViewport.right < AXIS_X_MAX); boolean canScrollY = (currentViewport.top > AXIS_Y_MIN || currentViewport.bottom < AXIS_Y_MAX); /* * If you are zoomed in, currX or currY is * outside of bounds, and you aren't already * showing overscroll, then render the overscroll * glow edge effect. */ if (canScrollX && currX < 0 && edgeEffectLeft.isFinished() && !edgeEffectLeftActive) { edgeEffectLeft.onAbsorb((int)mScroller.getCurrVelocity()); edgeEffectLeftActive = true; needsInvalidate = true; } else if (canScrollX && currX > (surfaceSize.x - contentRect.width()) && edgeEffectRight.isFinished() && !edgeEffectRightActive) { edgeEffectRight.onAbsorb((int)mScroller.getCurrVelocity()); edgeEffectRightActive = true; needsInvalidate = true; } if (canScrollY && currY < 0 && edgeEffectTop.isFinished() && !edgeEffectTopActive) { edgeEffectRight.onAbsorb((int)mScroller.getCurrVelocity()); edgeEffectTopActive = true; needsInvalidate = true; } else if (canScrollY && currY > (surfaceSize.y - contentRect.height()) && edgeEffectBottom.isFinished() && !edgeEffectBottomActive) { edgeEffectRight.onAbsorb((int)mScroller.getCurrVelocity()); edgeEffectBottomActive = true; needsInvalidate = true; } ... }
Ecco la sezione del codice che esegue lo zoom effettivo:
Kotlin
lateinit var zoomer: Zoomer val zoomFocalPoint = PointF() ... // If a zoom is in progress—either programmatically // or through double touch—this performs the zoom. if (zoomer.computeZoom()) { val newWidth: Float = (1f - zoomer.currZoom) * scrollerStartViewport.width() val newHeight: Float = (1f - zoomer.currZoom) * scrollerStartViewport.height() val pointWithinViewportX: Float = (zoomFocalPoint.x - scrollerStartViewport.left) / scrollerStartViewport.width() val pointWithinViewportY: Float = (zoomFocalPoint.y - scrollerStartViewport.top) / scrollerStartViewport.height() currentViewport.set( zoomFocalPoint.x - newWidth * pointWithinViewportX, zoomFocalPoint.y - newHeight * pointWithinViewportY, zoomFocalPoint.x + newWidth * (1 - pointWithinViewportX), zoomFocalPoint.y + newHeight * (1 - pointWithinViewportY) ) constrainViewport() needsInvalidate = true } if (needsInvalidate) { ViewCompat.postInvalidateOnAnimation(this) }
Java
// Custom object that is functionally similar to Scroller. Zoomer zoomer; private PointF zoomFocalPoint = new PointF(); ... // If a zoom is in progress—either programmatically // or through double touch—this performs the zoom. if (zoomer.computeZoom()) { float newWidth = (1f - zoomer.getCurrZoom()) * scrollerStartViewport.width(); float newHeight = (1f - zoomer.getCurrZoom()) * scrollerStartViewport.height(); float pointWithinViewportX = (zoomFocalPoint.x - scrollerStartViewport.left) / scrollerStartViewport.width(); float pointWithinViewportY = (zoomFocalPoint.y - scrollerStartViewport.top) / scrollerStartViewport.height(); currentViewport.set( zoomFocalPoint.x - newWidth * pointWithinViewportX, zoomFocalPoint.y - newHeight * pointWithinViewportY, zoomFocalPoint.x + newWidth * (1 - pointWithinViewportX), zoomFocalPoint.y + newHeight * (1 - pointWithinViewportY)); constrainViewport(); needsInvalidate = true; } if (needsInvalidate) { ViewCompat.postInvalidateOnAnimation(this); }
Questo è il metodo computeScrollSurfaceSize()
richiamato nello snippet precedente. Calcola le dimensioni attuali della superficie di scorrimento
in pixel. Ad esempio, se è visibile l'intera area del grafico, questa è la dimensione
attuale di mContentRect
. Se il grafico viene ingrandito del 200% in entrambe le direzioni, le dimensioni restituite sono due volte più grandi, sia orizzontalmente che verticalmente.
Kotlin
private fun computeScrollSurfaceSize(): Point { return Point( (contentRect.width() * (AXIS_X_MAX - AXIS_X_MIN) / currentViewport.width()).toInt(), (contentRect.height() * (AXIS_Y_MAX - AXIS_Y_MIN) / currentViewport.height()).toInt() ) }
Java
private Point computeScrollSurfaceSize() { return new Point( (int) (contentRect.width() * (AXIS_X_MAX - AXIS_X_MIN) / currentViewport.width()), (int) (contentRect.height() * (AXIS_Y_MAX - AXIS_Y_MIN) / currentViewport.height())); }
Per un altro esempio di utilizzo dello scorrimento, consulta il
codice sorgente
per la classe ViewPager
. Scorre in risposta agli incroci e usa
lo scorrimento per implementare l'animazione "snap-to-page".
Implementare l'effetto Allungamento overscroll
A partire da Android 12, EdgeEffect
aggiunge le seguenti API per l'implementazione dell'effetto overscroll allungato:
getDistance()
onPullDistance()
Per offrire la migliore esperienza utente con stretching overscroll, segui questi passaggi:
- Quando l'animazione di allungamento è attiva quando l'utente tocca i contenuti, registra il tocco come "cattura". L'utente interrompe l'animazione e inizia a modificare di nuovo l'elastico.
- Quando l'utente muove il dito nella direzione opposta dell'elasticità, rilascia l'elastico finché non è completamente terminato, quindi inizia a scorrere.
- Quando l'utente si muove durante lo stretching, lancia
EdgeEffect
per migliorare l'effetto di stretching.
Non perderti l'animazione
Quando un utente cattura un'animazione di stretching attiva,
EdgeEffect.getDistance()
restituisce 0
. Questa condizione
indica che l'allungamento deve essere manipolato dal movimento del tocco. Nella maggior parte dei container, l'intercettazione viene rilevata in onInterceptTouchEvent()
, come mostrato nel seguente snippet di codice:
Kotlin
override fun onInterceptTouchEvent(ev: MotionEvent): Boolean { ... when (action and MotionEvent.ACTION_MASK) { MotionEvent.ACTION_DOWN -> ... isBeingDragged = EdgeEffectCompat.getDistance(edgeEffectBottom) > 0f || EdgeEffectCompat.getDistance(edgeEffectTop) > 0f ... } return isBeingDragged }
Java
@Override public boolean onInterceptTouchEvent(MotionEvent ev) { ... switch (action & MotionEvent.ACTION_MASK) { case MotionEvent.ACTION_DOWN: ... isBeingDragged = EdgeEffectCompat.getDistance(edgeEffectBottom) > 0 || EdgeEffectCompat.getDistance(edgeEffectTop) > 0; ... } }
Nell'esempio precedente, onInterceptTouchEvent()
restituisce
true
quando mIsBeingDragged
è true
, quindi
è sufficiente consumare l'evento prima che l'asset secondario abbia l'opportunità di
usufruirlo.
Rilascia l'effetto overscroll
È importante rilasciare l'effetto di allungamento prima di scorrere per evitare che l'estensione venga applicata ai contenuti scorrevoli. Il seguente esempio di codice applica questa best practice:
Kotlin
override fun onTouchEvent(ev: MotionEvent): Boolean { val activePointerIndex = ev.actionIndex when (ev.getActionMasked()) { MotionEvent.ACTION_MOVE -> val x = ev.getX(activePointerIndex) val y = ev.getY(activePointerIndex) var deltaY = y - lastMotionY val pullDistance = deltaY / height val displacement = x / width if (deltaY < 0f && EdgeEffectCompat.getDistance(edgeEffectTop) > 0f) { deltaY -= height * EdgeEffectCompat.onPullDistance(edgeEffectTop, pullDistance, displacement); } if (deltaY > 0f && EdgeEffectCompat.getDistance(edgeEffectBottom) > 0f) { deltaY += height * EdgeEffectCompat.onPullDistance(edgeEffectBottom, -pullDistance, 1 - displacement); } ... }
Java
@Override public boolean onTouchEvent(MotionEvent ev) { final int actionMasked = ev.getActionMasked(); switch (actionMasked) { case MotionEvent.ACTION_MOVE: final float x = ev.getX(activePointerIndex); final float y = ev.getY(activePointerIndex); float deltaY = y - lastMotionY; float pullDistance = deltaY / getHeight(); float displacement = x / getWidth(); if (deltaY < 0 && EdgeEffectCompat.getDistance(edgeEffectTop) > 0) { deltaY -= getHeight() * EdgeEffectCompat.onPullDistance(edgeEffectTop, pullDistance, displacement); } if (deltaY > 0 && EdgeEffectCompat.getDistance(edgeEffectBottom) > 0) { deltaY += getHeight() * EdgeEffectCompat.onPullDistance(edgeEffectBottom, -pullDistance, 1 - displacement); } ...
Quando l'utente esegue il trascinamento, utilizza la distanza di pull EdgeEffect
prima di passare l'evento touch a un contenitore di scorrimento nidificato o trascinare lo scorrimento. Nell'esempio di codice precedente, getDistance()
restituisce un valore positivo quando viene visualizzato un effetto bordo che può essere rilasciato con il movimento. Quando l'evento tocco rilascia l'estensione, viene prima consumato dall'EdgeEffect
in modo che venga rilasciato completamente prima che vengano visualizzati altri effetti, come lo scorrimento nidificato. Puoi usare getDistance()
per scoprire quanta distanza di pull è necessaria per rilasciare l'effetto corrente.
A differenza di onPull()
, onPullDistance()
restituisce la quantità consumata del delta passato. A partire da Android 12, se
onPull()
o onPullDistance()
vengono passati valori negativi
deltaDistance
quando getDistance()
è
0
, l'effetto di allungamento non cambia. Su Android 11
e versioni precedenti, onPull()
consente ai valori negativi per la distanza totale
di mostrare effetti di bagliore.
Disattiva l'overscroll
Puoi disattivare l'overscroll nel file di layout o in modo programmatico.
Per disattivarla nel file di layout, imposta android:overScrollMode
come
mostrato nell'esempio seguente:
<MyCustomView android:overScrollMode="never"> ... </MyCustomView>
Per disattivare la funzionalità in modo programmatico, utilizza un codice simile al seguente:
Kotlin
customView.overScrollMode = View.OVER_SCROLL_NEVER
Java
customView.setOverScrollMode(View.OVER_SCROLL_NEVER);
Risorse aggiuntive
Consulta le seguenti risorse correlate:
- Panoramica degli eventi di input
- Panoramica dei sensori
- Rendere interattiva una visualizzazione personalizzata