Kaydırma hareketini canlandırma

"Oluştur" yöntemini deneyin

Jetpack Compose, Android için önerilen kullanıcı arayüzü araç setidir. Oluşturma'da dokunma ve giriş özelliklerini nasıl kullanacağınızı öğrenin.

Kaydırılıyor → 'nı inceleyin.

Android'de, kaydırma işlemi genellikle ScrollView. sınıfını kullanır. Sınırlarını aşan her standart düzeni Nest içine yerleştirin: tarafından yönetilen kaydırılabilir bir görünüm sağlamak için ScrollView içinde bir kapsayıcı bilmek zorundasınız. Özel bir kaydırma çubuğu kullanmak yalnızca senaryoları ele alacağız. Bu dokümanda, yanıtta kaydırma efektinin nasıl gösterileceği açıklanmaktadır. kaydırıcıları kullanarak dokunma hareketlerini kullanabilirsiniz.

Uygulamanız şunları kullanabilir: kaydırıcılar - Scroller veya OverScroller - hedef Bir dokunmaya yanıt olarak kayan bir animasyon üretmek için gereken verileri toplamak unutmayın. Bunlar benzerdir ancak OverScroller, şunlar için yöntemler de içerir: kullanıcılara, bir kaydırma veya hızlı kaydırma işleminden sonra içerik kenarlarına ulaştıklarında bunu gösteriyor. hareketi yapın.

• Android 12'den (API düzeyi 31) başlayarak görsel öğeler uzatılır ve zıplar ve hızlı bir şekilde fırlatma etkinliğinde geri dönmesi.
• Android 11 (API düzeyi 30) ve önceki sürümlerde sınırlar bir "parıltı" olarak görünür kenara kaydırma veya sürükleme hareketinden sonra bir efekt yaratır.

Bu dokümandaki InteractiveChart örneğinde EdgeEffect sınıfını kullanır.

Zaman içinde kaydırmayı canlandırmak için platform standardı olan kaydırma fiziği, örneğin sürtünme, hız ve diğer nitelikleridir. Kaydırıcının kendisi hiçbir şey çizmez. Scrollers kaydırma parçaları görebilirsiniz, ancak bu konumları otomatik olarak görünümünüzle aynı içeriğe sahiptir. Yeni koordinatlar almalı ve bu koordinatları düzgün görünüyor.

Kaydırma terminolojisini anlama

Kaydırma, Android'de Android'de farklı anlama gelebilen bir kelimedir. bilmek önemlidir.

Kaydırma, görüntü alanını taşıma işlemidir, yani "pencere" görebilirsiniz. Kaydırma hem x ve y eksenlerine kaydırma denir. İlgili içeriği oluşturmak için kullanılan Bu belgedeki InteractiveChart örnek uygulama iki uygulamayı gösteriyor Farklı kaydırma, sürükleme ve hızla kaydırma türleri:

• Sürükleme: Bu, kullanıcı bir öğeyi parmaklarını dokunmatik ekranda sürükler. Sürüklemeyi uygulamak için geçersiz kılma onScroll(). inç GestureDetector.OnGestureListener. Sürükleme hakkında daha fazla bilgi için bkz. Sürükleyin ve ölçeklendirin.
• Kaydırma: Bu, bir kullanıcı aşağıdaki işlemleri gerçekleştirdiğinde gerçekleşen kaydırma türüdür. parmağını hızlı şekilde sürükleyip kaldırıyor. Kullanıcı parmağını kaldırdıktan sonra genellikle görüntü alanını hareket ettirmeye devam etmek isteyebilirsiniz, ancak görüntü alanının hareket etmesi durur. onFling(). GestureDetector.OnGestureListener içinde ve kaydırma çubuğu kullanarak nesnesini tanımlayın.
• Kaydırma: Aynı anda hem x- hem de y eksenlerine kaydırma denir.

Kaydırma nesneleri, hızla kaydırma hareketiyle birlikte yaygın bir şekilde kullanılır, ancak bunları, kullanıcı arayüzünün kaydırma sayfasında görünmesini istediğiniz herhangi bir bağlamda kullanabilirsiniz. yanıt verebilir. Örneğin, onTouchEvent(). kullanarak dokunma etkinliklerini doğrudan işlemek ve kaydırma efekti veya "sayfaya tuttur" animasyon eklemek için kullanılır.

Yerleşik kaydırma uygulamaları içeren bileşenler

Aşağıdaki Android bileşenleri, yerleşik kaydırma desteği ve fazla kaydırma davranışı:

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

Uygulamanızın, farklı bir tablodaki kaydırmayı ve fazla kaydırmayı desteklemesi gerekiyorsa bileşeni için aşağıdaki adımları tamamlayın:

1. Dokunmaya dayalı özel kaydırma oluşturma hakkında daha fazla bilgi edinin.
2. Android 12 ve sonraki sürümleri çalıştıran cihazları desteklemek için: esneme işlemini uygulayarak etkisi.

Özel bir dokunmaya dayalı kaydırma uygulaması oluşturma

Bu bölümde, uygulamanızda çalışmayan bir bileşen yerleşik destek içermesi kaydırma ve fazla kaydırma gibi özellikler vardır.

Aşağıdaki snippet InteractiveChart örnek bölümüne bakın. Bir GestureDetector. ve GestureDetector.SimpleOnGestureListener yöntem onFling(). Şunu izlemek için OverScroller kullanıyor: hızla vurma hareketi. Kullanıcı, aşağıdakileri gerçekleştirdikten sonra içerik kenarlarına ulaşırsa hızlıca kaydırma hareketiyle, kapsayıcı, kullanıcının reklamın içerik. Bu gösterge, cihazın Android sürümüne göre çalışır:

• Android 12 ve sonraki sürümlerde görsel öğeler esnektir ve geri dönebilir.
• Android 11 ve önceki sürümlerde görsel öğeler parıltıya kavuşur etkisi.

Aşağıdaki snippet'in ilk bölümü, 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);
}

onFling() aradığında postInvalidateOnAnimation(), tetikleyici computeScroll() x ve y değerlerini güncelleyin. Bu genellikle bir ekip üyesinin önceki örnekte gösterildiği gibi, kaydırma çubuğu nesnesini kullanarak bir kaydırmayı örneğine bakalım.

Çoğu görünüm, kaydırıcı nesnesinin x ve y konumunu doğrudan geçirir - scrollTo(). Aşağıdaki computeScroll() uygulaması, farklı bir yaklaşım: computeScrollOffset() için x ve y konumlarının geçerli konumunu alabilirsiniz. Projedeki kriterler fazla kaydırılan bir "parıltı" görüntüleniyor bir kenar efektiyle karşılaştırıldığında, yakınlaştırıldıysa, x veya y sınırların dışındaysa ve uygulama henüz değilse gösteren bir kaydırma efektini görüntüler; kod, fazla kaydırma parlama efektini postInvalidateOnAnimation() görünüm.

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

Kodun gerçek yakınlaştırma işlemini gerçekleştiren bölümü aşağıda verilmiştir:

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

computeScrollSurfaceSize() <br>Bu, yeni bir kod snippet'i ekleyin. Mevcut kaydırılabilir yüzey boyutunu piksel. Örneğin, grafik alanının tamamı görünür durumdaysa bu, mContentRect boyutu. Grafik her iki yönde de% 200 yakınlaştırıldığında yöne göre, döndürülen boyut yatay ve dikey olarak iki kat daha büyük olur.

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

Kaydırma çubuğu kullanımıyla ilgili başka bir örnek için kaynak kod ViewPager sınıfı için. Kısa mesajlara yanıt olarak kayarak "sayfaya tuttur" özelliğini uygulamak için kaydırma animasyon ekler.

Fazla kaydırma efektini uygulama

EdgeEffect, Android 12'den itibaren şunları ekler: uzatmak için kaydırma efektini uygulamak için aşağıdaki API'ları kullanın:

• getDistance()
• onPullDistance()

Fazla kaydırma yapıldığında en iyi kullanıcı deneyimini sağlamak için takip etmek için:

1. Kullanıcı bunu bir "yakalama" olarak kaydeder. Kullanıcı animasyonu durdurur ve gerginliği yeniden manipüle etmeye başlar.
2. Kullanıcı parmağını gerilmenin tersi yönünde hareket ettirdiğinde gerginliği tamamen geçene kadar serbest bırakın ve ardından kaydırmaya başlayın.
3. Kullanıcı esneme sırasında hızla hareket ettiğinde EdgeEffect kullanarak esneme efektini geliştirebilirsiniz.

Animasyonu yakalama

Kullanıcı etkin bir uzatma animasyonu yakaladığında EdgeEffect.getDistance(), 0 değerini döndürür. Bu koşul esnemenin dokunma hareketiyle değiştirilmesi gerektiğini belirtir. Çoğu zaman kapsayıcılarda yakalanan içerik onInterceptTouchEvent() içinde algılanır (ör. aşağıdaki kod snippet'inde gösterilmektedir:

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

Yukarıdaki örnekte onInterceptTouchEvent(), mIsBeingDragged, true olduğunda true, yani Henüz etkinlik başlamadan önce tüketilmesi yeterlidir. onu tüketirim.

Fazla kaydırma efektini bırakın

Esneme efektini, sayfa içeriğini kaydırmadan önce esnemenin kayan içeriğe uygulanmasını engeller. Aşağıdaki kod örneği şu en iyi uygulamayı uygular:

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

Kullanıcı sürüklerken EdgeEffect çekme mesafesini kullan dokunma etkinliğini iç içe yerleştirilmiş bir kaydırma kapsayıcısına iletmeden veya kaydırabilirsiniz. Önceki kod örneğinde getDistance(), bir bir efekt görüntülenirken pozitif değer elde edilir ve efekt hareket ettirir. Dokunma etkinliği gerilmeyi serbest bıraktığında, ilk olarak uzantı tarafından tüketilir. Diğer efektlerden önce tamamen yayınlanacak şekilde EdgeEffect. gibi reklam öğeleri görüntülenir. getDistance() kullanabilirsiniz mevcut efektin uygulanması için ne kadar çekme mesafesi gerektiğini öğrenin.

onPull() işlevinden farklı olarak onPullDistance(), tüketilen delta miktarıdır. Android 12'de kullanıma sunulmak üzere onPull() veya onPullDistance() negatif olarak iletildi getDistance() şu durumda olduğunda deltaDistance değerleri: 0, uzatma efekti değişmez. Android 11'de ve öncesi için onPull(), toplam mesafe için negatif değerlere izin verir parlaklık efektlerini göster.

Fazla kaydırmayı devre dışı bırak

Fazla kaydırmayı düzen dosyanızda veya programatik olarak devre dışı bırakabilirsiniz.

Düzen dosyanızda devre dışı bırakmak için android:overScrollMode öğesini şu şekilde ayarlayın: aşağıdaki örnekte gösterilmektedir:

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

Programatik olarak devre dışı bırakmak için aşağıdaki gibi bir kod kullanın:

customView.overScrollMode = View.OVER_SCROLL_NEVER

customView.setOverScrollMode(View.OVER_SCROLL_NEVER);

Ek kaynaklar

Aşağıdaki ilgili kaynaklara bakın:

• Giriş etkinliklerine genel bakış
• Sensörlere genel bakış
• Özel görünümü etkileşimli hale getirme