Anima un gesto di scorrimento

Prova la funzionalità Scrivi

Jetpack Compose è il toolkit per l'interfaccia utente consigliato per Android. Scopri come utilizzare il tocco e l'input in Compose.

Scorri →

In Android, lo scorrimento viene in genere ottenuto utilizzando la classe ScrollView. Innestare qualsiasi layout standard che potrebbe estendersi oltre i confini del suo contenuto in un ScrollView per fornire una visualizzazione scorrevole gestita dal framework. L'implementazione di uno scroller personalizzato è necessaria solo per scenari speciali. Questo documento descrive come visualizzare un effetto di scorrimento in risposta ai gesti tocco utilizzando gli scroller.

La tua app può utilizzare gli scorrevoli (Scroller o OverScroller) per raccogliere i dati necessari per produrre un'animazione con scorrimento in risposta a un evento di tocco. Sono simili, ma OverScroller include anche metodi per indicare agli utenti quando raggiungono i bordi dei contenuti dopo un gesto di panoramica o scorrimento.

• A partire da Android 12 (livello API 31), gli elementi visivi si allungano e tornano indietro in seguito a un evento di trascinamento e si spostano e tornano indietro in seguito a un evento fling.
• Su Android 11 (livello API 30) e versioni precedenti, i confini mostrano un effetto "bagliore" dopo un gesto di trascinamento o lancio verso il bordo.

L'esempio InteractiveChart in questo documento utilizza la classe EdgeEffect per visualizzare questi effetti di scorrimento eccessivo.

Puoi utilizzare uno scroller per animare lo scorrimento nel tempo, utilizzando la fisica dello scorrimento standard della piattaforma, come attrito, velocità e altre qualità. Lo scorrevole stesso non disegna nulla. I cursori monitorano gli offset scorrimento nel tempo, ma non applicano automaticamente queste posizioni alla visualizzazione. Devi ottenere e applicare nuove coordinate a una velocità che renda scorrevole l'animazione.

Informazioni sulla terminologia relativa allo scorrimento

Scorri è una parola che può avere significati diversi in Android, a seconda del contesto.

Lo scorrimento è il processo generale di spostamento dell'area visibile, ovvero la"finestra" dei contenuti che stai visualizzando. Quando lo scorrimento avviene sia sull'asse x sia sull'asse y, si parla di panoramica. L'app di esempio InteractiveChart in questo documento illustra due diversi tipi di scorrimento, trascinamento e lancio:

• Trasciamento:si tratta del tipo di scorrimento che si verifica quando un utente scorra il dito sul touchscreen. Puoi implementare il trascinamento overriding onScroll() in GestureDetector.OnGestureListener. Per ulteriori informazioni sul trascinamento, consulta Trascinare e ridimensionare.
• Scorrimento con movimento brusco:si tratta del tipo di scorrimento che si verifica quando un utente trascina e solleva rapidamente il dito. Dopo che l'utente ha sollevato il dito, generalmente è consigliabile continuare a spostare l'area visibile, ma decelerare fino a quando non si ferma. Puoi implementare il trascinamento sostituendo onFling() in GestureDetector.OnGestureListener e utilizzando un oggetto scroller.
• Panoramica:lo scorrimento contemporaneamente lungo gli assi x e y è chiamato panoramica.

È comune utilizzare gli oggetti scroller in combinazione con un gesto di scorrimento, ma puoi utilizzarli in qualsiasi contesto in cui vuoi che l'interfaccia utente mostri lo scorrimento in risposta a un evento tocco. Ad esempio, puoi eseguire l'override onTouchEvent() per elaborare direttamente gli eventi touch e produrre un effetto di scorrimento o un'animazione "snap-to-page" in risposta a questi eventi touch.

Componenti che contengono implementazioni di scorrimento integrate

I seguenti componenti Android contengono il supporto integrato per il comportamento di scorrimento e scorrimento eccessivo:

• GridView
• HorizontalScrollView
• ListView
• NestedScrollView
• RecyclerView
• ScrollView
• ViewPager
• ViewPager2

Se la tua app deve supportare lo scorrimento e lo scorrimento oltre il limite in un componente diverso, segui questi passaggi:

1. Crea un'implementazione personalizzata dello scorrimento basato su tocco.
2. Per supportare i dispositivi con Android 12 e versioni successive, implementa l'effetto di scorrimento con stretching.

Creare un'implementazione di scorrimento basata su tocco personalizzata

Questa sezione descrive come creare un scroller personalizzato se la tua app utilizza un componente che non supporta lo scorrimento e lo scorrimento eccessivo.

Il seguente snippet proviene dall'InteractiveChart esempio. Utilizza un GestureDetector e sostituisce il GestureDetector.SimpleOnGestureListener metodo onFling(). Utilizza OverScroller per monitorare il gesto di lancio. Se l'utente raggiunge i bordi dei contenuti dopo aver eseguito il gesto di scorrimento, il contenitore indica quando l'utente raggiunge la fine dei contenuti. L'indicazione dipende dalla versione di Android in esecuzione sul dispositivo:

• Su Android 12 e versioni successive, gli elementi visivi si allungano e si ritrascinano.
• Su Android 11 e versioni precedenti, gli elementi visivi mostrano un effetto di bagliore.

La prima parte dello snippet seguente mostra l'implementazione di onFling():

// 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)
}

// 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 computeScroll() per aggiornare i valori di x e y. Questo viene in genere eseguito quando una vista secondaria anima uno scorrimento utilizzando un oggetto scroller, come mostrato nell'esempio precedente.

La maggior parte delle visualizzazioni passa la posizione x e y dell'oggetto scroller direttamente a scrollTo(). La seguente implementazione di computeScroll() adotta un approccio diverso: chiama computeScrollOffset() per ottenere la posizione corrente di x e y. Quando vengono soddisfatti i criteri per la visualizzazione di un effetto di bordo "bagliore" per lo scorrimento eccessivo, ovvero se il display è ingrandito, x o y non è compreso nell'intervallo consentito e l'app non mostra già uno scorrimento eccessivo, il codice imposta l'effetto bagliore per lo scorrimento eccessivo e chiama postInvalidateOnAnimation() per attivare un'invalidazione nella visualizzazione.

// 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
        }
        ...
    }
}

// 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 di codice che esegue lo zoom effettivo:

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)
}

// 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() chiamato nel lo snippet precedente. Calcola le dimensioni correnti della superficie scorrevole in pixel. Ad esempio, se l'intera area del grafico è visibile, si tratta delle dimensioni attuali di mContentRect. Se il grafico viene ingrandito del 200% in entrambe le direzioni, le dimensioni restituite sono il doppio rispetto a quelle orizzontali e verticali.

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()
    )
}

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 scorrevole, consulta il codice sorgente per la classe ViewPager. Scorri in risposta ai movimenti rapidi e utilizza scorrimento per implementare l'animazione "Aggiusta a pagina".

Implementare l'effetto di scorrimento elastico

A partire da Android 12, EdgeEffect aggiunge le seguenti API per implementare l'effetto di scorrimento elastico:

• getDistance()
• onPullDistance()

Per offrire la migliore esperienza utente con lo scorrimento elastico, segui quanto segue:

1. Quando l'animazione di allungamento è attiva e l'utente tocca i contenuti, registra il tocco come "presa". L'utente interrompe l'animazione e inizia di nuovo a manipolare lo stretching.
2. Quando l'utente muove il dito nella direzione opposta all'allungamento, deve rilasciare la pressione finché l'allungamento non scompare completamente, quindi iniziare a scorrere.
3. Quando l'utente esegue un movimento brusco durante uno stretching, esegui un movimento brusco su EdgeEffect per migliorare l'effetto di stretching.

Catturare l'animazione

Quando un utente acquisisce un'animazione di allungamento attiva, EdgeEffect.getDistance() restituisce 0. Questa condizione indica che lo stretching deve essere manipolato dal movimento tocco. Nella maggior parte dei contenitori, l'errore viene rilevato in onInterceptTouchEvent(), come mostrato nel seguente snippet di codice:

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
}

@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 utilizzare l'evento prima che il child abbia l'opportunità di utilizzarlo.

Rilasciare l'effetto di scorrimento eccessivo

È importante rilasciare l'effetto di allungamento prima di scorrere per evitare che venga applicato ai contenuti in scorrimento. Il seguente codice di esempio applica questa best practice:

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);
      }
      ...
  }

@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 trascina, utilizza la distanza di trazione EdgeEffect prima di passare l'evento tocco a un contenitore con scorrimento nidificato o di trascinare lo scorrimento. Nell'esempio di codice precedente, getDistance() restituisce un valore positivo quando viene visualizzato un effetto bordo e può essere rilasciato con il movimento. Quando l'evento tocco rilascia lo stretching, viene prima utilizzato da EdgeEffect in modo che venga rilasciato completamente prima che vengano visualizzati altri effetti, come lo scorrimento nidificato. Puoi utilizzare getDistance() per sapere quanto è necessaria la distanza di trazione per rilasciare l'effetto corrente.

A differenza di onPull(), onPullDistance() restituisce la quantità consumata del delta passato. A partire da Android 12, se vengono passati valori deltaDistance negativi a onPull() o onPullDistance() quando getDistance() è 0, l'effetto di allungamento non cambia. Su Android 11 e versioni precedenti, onPull() consente di mostrare effetti di illuminazione per i valori negativi della distanza totale.

Disattivare lo scorrimento eccessivo

Puoi disattivare lo scorrimento eccessivo nel file di layout o tramite programmazione.

Per disattivare questa opzione 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 come il seguente:

customView.overScrollMode = View.OVER_SCROLL_NEVER

customView.setOverScrollMode(View.OVER_SCROLL_NEVER);

Risorse aggiuntive

Consulta le seguenti risorse correlate:

• Panoramica degli eventi di immissione
• Panoramica dei sensori
• Rendere interattiva una vista personalizzata