Anima un gesto di scorrimento

Prova il metodo Scrivi

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

Scorrimento → .

In Android, lo scorrimento si ottiene in genere utilizzando ScrollView . Nidificare qualsiasi layout standard che possa estendersi oltre i limiti del proprio contenitore in un ScrollView per fornire una visualizzazione scorrevole gestita il framework. L'implementazione di uno scorrimento personalizzato è necessaria solo per diversi scenari. Questo documento descrive come visualizzare un effetto di scorrimento in risposta per toccare i gesti con gli scorrimenti.

La tua app può usare scorrimenti: Scroller o OverScroller a Raccogliere i dati necessari per produrre un'animazione a scorrimento in risposta a un tocco . Sono simili, ma OverScroller include anche metodi per che indicano agli utenti quando raggiungono i bordi dei contenuti dopo una panoramica gesto.

• A partire da Android 12 (livello API 31), gli elementi visivi si allungano e rimbalzano in un evento di trascinamento, per poi scorrere e rimbalzare su un evento fling.
• Su Android 11 (livello API 30) e versioni precedenti, i limiti mostrano un "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 fisica dello scorrimento standard della piattaforma, come attrito, velocità e altre qualità del prodotto. Lo scorrimento in sé non disegna nulla. Scorrimento delle tracce con gli strumenti di scorrimento gli offset nel tempo, ma non applicano automaticamente queste posizioni la tua visualizzazione. Devi ottenere e applicare nuove coordinate a una velocità tale da rendere l'animazione a scorrimento sarà uniforme.

Comprendere la terminologia relativa allo scorrimento

Lo scorrimento è una parola che può assumere significati diversi in Android, a seconda contesto.

Lo scorrimento è la procedura generale di spostamento dell'area visibile, ovvero la "finestra" di contenuti che stai guardando. Quando lo scorrimento è in entrambe le modalità Gli assi x e y sono noti come panning. La InteractiveChart app di esempio in questo documento illustra due diversi tipi di scorrimento e trascinamento:

• Trascinamento: è il tipo di scorrimento che si verifica quando un utente trascina il dito sul touchscreen. Puoi implementare il trascinamento eseguire l'override onScroll() nel GestureDetector.OnGestureListener. Per ulteriori informazioni sul trascinamento, vedi Trascina e ridimensiona.
• Flinging: è il tipo di scorrimento che si verifica quando un utente trascina e solleva velocemente il dito. Dopo che l'utente ha sollevato il dito, in genere si vuole continuare a spostare l'area visibile, ma l'operazione rallenta finché l'area visibile si interrompe. Puoi implementare il fling eseguendo l'override onFling() in GestureDetector.OnGestureListener e con uno scorrimento .
• Panning:scorrimento simultaneo su x- e L'asse y è chiamato panning.

È comune utilizzare oggetti scorrimento in combinazione con un gesto di scorrimento, ma puoi utilizzarle in qualsiasi contesto in cui vuoi che l'UI mostri lo scorrimento risposta a un evento touch. Ad esempio, puoi eseguire l'override onTouchEvent() per elaborare direttamente gli eventi di tocco e produrre un effetto di scorrimento o un "Allinea alla pagina" dell'animazione in risposta a tali eventi touch.

Componenti che contengono implementazioni di scorrimento integrate

I seguenti componenti Android contengono il supporto integrato per lo scorrimento e comportamento dell'overscrolling:

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

Se l'app deve supportare lo scorrimento e l'overscrolling all'interno di un'altra , completa la seguente procedura:

1. Creare uno scorrimento personalizzato basato sul tocco implementazione.
2. Per supportare i dispositivi con Android 12 e versioni successive: implementa l'overscroll effetto.

Creare un'implementazione di scorrimento personalizzata basata sul tocco

Questa sezione descrive come creare un proprio cursore se l'app utilizza un che non esegue contengono il supporto integrato o scorrere troppo in alto.

Il seguente snippet proviene dalla InteractiveChart esempio. Utilizza un GestureDetector e sostituisce il valore GestureDetector.SimpleOnGestureListener metodo onFling(). Usa OverScroller per monitorare gesto di scorrimento. Se l'utente raggiunge il limite dei contenuti dopo aver eseguito la gesto flesso, il contenitore indica quando l'utente raggiunge la fine del contenuti. L'indicazione dipende dalla versione di Android utilizzata da un dispositivo corse:

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

La prima parte del seguente snippet mostra l'implementazione 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. In genere questo viene fatto quando vista figlio anima uno scorrimento utilizzando un oggetto cursore, come mostrato in precedenza esempio.

La maggior parte delle visualizzazioni trasmette direttamente la posizione x e y dell'oggetto a scorrimento a scrollTo(). La seguente implementazione di computeScroll() richiede un'impostazione diversa approccio: chiama computeScrollOffset() per ottenere la posizione corrente di x e y. Quando i criteri per mostra un "bagliore" overscroll vengono raggiunti gli effetti dei bordi, cioè lo schermo abbia aumentato lo zoom, x o y è fuori intervallo e l'app non lo è già che mostra un overscroll: il codice imposta l'effetto di bagliore overscroll chiama postInvalidateOnAnimation() per attivare un'azione di invalidamento vista.

// 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 del 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() che viene chiamato lo snippet precedente. Calcola l'attuale dimensione della superficie di scorrimento pixel. Ad esempio, se è visibile l'intera area del grafico, si tratta della dimensione corrente dimensioni di mContentRect. Se lo zoom del grafico è aumentato del 200% sia in direzioni, le dimensioni restituite sono due volte più grandi sia orizzontalmente che verticalmente.

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 scorrimento, vedi codice sorgente per il corso ViewPager. Scorre in risposta a scorrimenti e usa scorrere per implementare l'opzione "snap-to-page" l'animazione.

Implementare l'effetto Allungamento overscroll

A partire da Android 12, in EdgeEffect viene aggiunta la le seguenti API per l'implementazione dell'effetto overscroll allungato:

• getDistance()
• onPullDistance()

Per offrire la migliore esperienza utente con stretching overscroll, segui le seguenti:

1. Quando l'animazione di allungamento è attiva quando l'utente tocca il registra il tocco come un "catch". L'utente interrompe l'animazione e e inizia a manipolare di nuovo l'elasticità.
2. Quando l'utente muove il dito nella direzione opposta dell'elasticità, rilascia l'elastico finché non è completamente terminato, quindi inizia a scorrere.
3. Quando l'utente si lancia durante uno stretching, lancia EdgeEffect per migliorare l'effetto di stretching.

Non perderti l'animazione

Quando un utente immortala un'animazione di stretching attiva, EdgeEffect.getDistance() restituisce 0. Questa condizione indica che l'elasticità deve essere manipolata dal movimento tattile. Nella maggior parte dei casi, container, il recupero viene rilevato in onInterceptTouchEvent(), 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 fruire dell'evento prima che il bambino abbia l'opportunità di ne usufruiscano.

Rilascia l'effetto overscroll

È importante rilasciare l'effetto di allungamento prima di scorrere per evitare l'estensione dall'applicazione ai contenuti scorrevoli. Il seguente codice nel seguente esempio viene applicata 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 sta trascinando, utilizza la distanza di pull EdgeEffect prima di passare l'evento touch a un contenitore di scorrimento nidificato o trascinare scorri. Nell'esempio di codice precedente, getDistance() restituisce un valore positivo quando un effetto bordo viene visualizzato e può essere rilasciato con movimento. Quando l'evento tocco rilascia la tecnica allungata, viene consumata per la prima volta dalla EdgeEffect in modo che venga rilasciato completamente prima di altri effetti, ad esempio lo scorrimento nidificato. Puoi usare getDistance() per scoprire quanta distanza di pull è necessaria per rilasciare l'effetto corrente.

A differenza di onPull(), onPullDistance() restituisce il valore consumata del delta passato. A partire da Android 12, se onPull() o onPullDistance() sono stati superati con valori negativi Valori di deltaDistance quando getDistance() è 0, l'effetto allungamento non cambia. Su Android 11 e precedenti, onPull() consente valori negativi per la distanza totale per mostrare effetti di incandescenza.

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 come mostrato nell'esempio seguente:

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

Per disattivare la funzionalità in modo programmatico, utilizza un codice simile al seguente:

customView.overScrollMode = View.OVER_SCROLL_NEVER

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