Questa pagina è stata tradotta dall'API Cloud Translation.

Anima un gesto di scorrimento

In Android, in genere lo scorrimento si ottiene utilizzando la classe ScrollView. Nidifica qualsiasi layout standard che potrebbe estendersi oltre i limiti del suo container in un elemento 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 tattili utilizzando gli scorrimenti.

L'app può utilizzare gli strumenti di scorrimento Scroller o OverScroller per raccogliere i dati necessari per produrre un'animazione scorrevole in risposta a un evento 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 rimbalzano su un evento di trascinamento, oppure su un evento di fling che si ritrae.
Su Android 11 (livello API 30) e versioni precedenti, i confini mostrano un effetto "incandescenza" dopo un gesto di trascinamento o scorrimento verso il bordo.

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

Puoi usare uno di scorrimento per animare lo scorrimento nel tempo, usando le fisiche dello scorrimento standard della piattaforma come l'attrito, la velocità e altre qualità. La barra di scorrimento non disegna nulla. Gli strumenti di scorrimento tracciano gli intervalli di scorrimento per te nel tempo, ma non applicano automaticamente queste posizioni alla tua visualizzazione. Devi ottenere e applicare nuove coordinate a una velocità che renda l'animazione di scorrimento uniforme.

Comprendere la terminologia dello scorrimento

Scorrimento è 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 guardando. Quando lo scorrimento avviene su entrambi gli assi 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() in GestureDetector.OnGestureListener. Per maggiori informazioni sul trascinamento, vedi Trascinare e ridimensionare.
Scorrimento:è 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 vuoi continuare a spostare l'area visibile, ma decelerare finché non si ferma. Puoi implementare il fling eseguendo l'override di onFling() in GestureDetector.OnGestureListener e utilizzando un oggetto scroller.
Panoramica: lo scorrimento simultaneo su entrambi gli assi x e y è chiamato panning.

È comune utilizzare oggetti di scorrimento insieme a 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 di onTouchEvent() per elaborare direttamente gli eventi tocco e produrre un effetto di scorrimento o un'animazione "aggancia alla pagina" in risposta a tali eventi.

Componenti che contengono implementazioni dello scorrimento integrate

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

Se la tua app deve supportare lo scorrimento all'interno di un altro componente, procedi nel seguente modo:

Crea un'implementazione personalizzata dello scorrimento basato sul tocco.
Per supportare i dispositivi con Android 12 e versioni successive, implementa l'effetto di scorrimento orizzontale di estensione.

Crea un'implementazione personalizzata dello scorrimento basato sul tocco

Questa sezione descrive come creare un tuo cursore se la tua app utilizza un componente che non contiene il supporto integrato per lo scorrimento.

Il seguente snippet proviene dall'esempio di InteractiveChart. Utilizza un GestureDetector e sostituisce il metodo GestureDetector.SimpleOnGestureListener onFling(). Usa OverScroller per monitorare il gesto di scorrimento. 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 su cui è in esecuzione 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 bagliore.

Nota: l'app di esempio InteractiveChart mostra un grafico su cui puoi eseguire lo zoom, la panoramica o lo scorrimento. Nello snippet seguente, contentRect rappresenta le coordinate del rettangolo all'interno della visualizzazione in cui è disegnato il grafico. In qualsiasi momento, un sottoinsieme del dominio totale e dell'intervallo del grafico vengono tracciati in questa area rettangolare. currentViewport rappresenta la parte del grafico visibile sullo schermo. Poiché gli offset di pixel vengono generalmente trattati come numeri interi, contentRect è di tipo Rect. Poiché il dominio e l'intervallo del grafico sono valori decimali o mobili, currentViewport è del tipo RectF.

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(), si attiva computeScroll() per aggiornare i valori di x e y. In genere, questa operazione viene eseguita quando una visualizzazione secondaria anima uno scorrimento utilizzando un oggetto di scorrimento, come mostrato nell'esempio precedente.

La maggior parte delle viste passa la posizione x e y dell'oggetto di scorrimento direttamente a scrollTo(). La seguente implementazione di computeScroll() ha un approccio diverso: chiama computeScrollOffset() per ottenere la posizione corrente di x e y. Quando vengono soddisfatti i criteri per visualizzare un effetto bordo "glow" di scorrimento orizzontale, ovvero se lo schermo viene ingrandito, x o y è al di fuori dei limiti e l'app non mostra già uno scorrimento orizzontale, il codice imposta l'effetto bagliore di scorrimento orizzontale e chiama postInvalidateOnAnimation() per attivare un annullamento della validità della 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() chiamato nello snippet precedente. Calcola l'attuale dimensione della superficie scorribile in pixel. Ad esempio, se è visibile l'intera area del grafico, questa è la dimensione corrente di mContentRect. Se il grafico viene ingrandito del 200% in entrambe le direzioni, la dimensione restituita è due volte più grande orizzontalmente e 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. Scorri in risposta a scorrimenti e utilizza lo scorrimento per implementare l'animazione "Allinea alla pagina".

Implementazione dell'effetto di scorrimento orizzontale

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

getDistance()
onPullDistance()

Per offrire la migliore esperienza utente possibile con lo scorrimento orizzontale, procedi nel seguente modo:

Quando l'animazione con stretching è attiva quando l'utente tocca i contenuti, registra il tocco come "catch". L'utente interrompe l'animazione e inizia a manipolare di nuovo il tratto.
Quando l'utente sposta il dito nella direzione opposta dello stretching, rilascialo finché non è completamente scomparso, quindi inizia a scorrere.
Quando l'utente volteggia durante lo stretching, lancia la EdgeEffect per migliorare l'effetto.

Non perderti l'animazione

Quando un utente rileva un'animazione di stretching attiva, EdgeEffect.getDistance() restituisce 0. Questa condizione indica che lo stiramento deve essere manipolato dal movimento tattile. Nella maggior parte dei container, il fermo viene rilevato 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'elemento secondario abbia l'opportunità di utilizzarlo.

Rilascia l'effetto scorrimento orizzontale

È importante rilasciare l'effetto Estendi prima di scorrere per evitare che lo venga applicato ai contenuti dello scorrimento. 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);
      }
            ...

Durante il trascinamento dell'utente, utilizza la distanza di pull EdgeEffect prima di passare l'evento touch a un contenitore a scorrimento nidificato oppure trascina lo scorrimento. Nell'esempio di codice precedente, getDistance() restituisce un valore positivo quando viene visualizzato un effetto bordo che può essere rilasciato con movimento. Quando l'evento touch rilascia il tratto, viene utilizzato per la prima volta dall'EdgeEffect, in modo che venga rilasciato completamente prima che vengano visualizzati altri effetti, come lo scorrimento nidificato. Puoi utilizzare getDistance() per sapere quanta distanza di tiro è necessaria per rilasciare l'effetto corrente.

A differenza di onPull(), onPullDistance() restituisce la quantità consumata del delta passato. A partire da Android 12, se a 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 della distanza totale di mostrare effetti di luminescenza.

Disattiva l'overScorrimento

Puoi disattivare l'overscroll nel file di layout o in modo programmatico.

Per disattivare la funzionalità nel file di layout, imposta android:overScrollMode come mostrato nell'esempio seguente:

<MyCustomView android:overScrollMode="never">
    ...
</MyCustomView>

Per effettuare la disattivazione programmatica, utilizza codice come il seguente:

Kotlin

customView.overScrollMode = View.OVER_SCROLL_NEVER

Java

customView.setOverScrollMode(View.OVER_SCROLL_NEVER);

Risorse aggiuntive

Fai riferimento alle seguenti risorse correlate: