Kaydırma hareketini canlandırma

Yazma yöntemini deneyin
Jetpack Compose, Android için önerilen kullanıcı arayüzü araç setidir. Compose'da dokunma ve giriş işlemlerini nasıl kullanacağınızı öğrenin.

Android'de kaydırma işlemi genellikle ScrollView sınıfı kullanılarak yapılır. Kapsayıcısının sınırlarını aşabilecek standart düzenleri, çerçeve tarafından yönetilen kaydırılabilir bir görünüm sağlamak için ScrollView içine yerleştirin. Özel kaydırma çubuğu uygulamak yalnızca özel senaryolarda gereklidir. Bu belgede, scroller kullanarak dokunma hareketlerine yanıt olarak kaydırma efektinin nasıl görüntüleneceği açıklanmaktadır.

Uygulamanız, dokunma etkinliğine yanıt olarak kaydırma animasyonu oluşturmak için gereken verileri toplamak üzere kaydırma çubuklarını (Scroller) veya (OverScroller) kullanabilir. Bu iki yöntem benzerdir ancak OverScroller, kaydırma veya hızlıca kaydırma hareketinden sonra içerik kenarlarına ulaştıklarında kullanıcıları bilgilendirme yöntemlerini de içerir.

  • Android 12'den (API düzeyi 31) itibaren görsel öğeler, sürükleme etkinliğinde uzayıp geri seker, hızlıca kaydırma etkinliğinde ise hızlıca kaydırılıp geri seker.
  • Android 11 (API düzeyi 30) ve önceki sürümlerde, kenara sürükleme veya hızlıca kaydırma hareketinden sonra sınırlarda "parlama" efekti gösterilir.

Bu belgedeki InteractiveChart örneğinde, bu aşırı kaydırma efektlerini göstermek için EdgeEffect sınıfı kullanılır.

Kaydırma çubuğu kullanarak sürtünme, hız ve diğer nitelikler gibi platform standardı kaydırma fiziğini kullanarak zaman içinde kaydırmayı canlandırabilirsiniz. Kaydırma çubuğunun kendisi hiçbir şey çizmez. Kaydırma çubukları, zaman içinde kaydırma uzaklıklarını sizin için izler ancak bu konumları görünümünüze otomatik olarak uygulamaz. Kaydırma animasyonunun sorunsuz görünmesini sağlayacak bir hızda yeni koordinatlar alıp uygulamanız gerekir.

Kaydırma terimlerini anlama

Kaydırma, bağlama bağlı olarak Android'de farklı anlamlara gelebilen bir kelimedir.

Kaydırma, görüntü alanını (yani baktığınız içerik "penceresini") hareket ettirme işlemidir. Hem x hem de y ekseninde kaydırma işlemine panoramik kaydırma denir. Bu belgedeki InteractiveChart örnek uygulamasında iki farklı kaydırma, sürükleme ve fırlatma türü gösterilmektedir:

  • Sürükleme: Bu, kullanıcının parmağını dokunmatik ekranda sürüklediğinde gerçekleşen kaydırma türüdür. Sürükleme işlevini, onScroll() içinde GestureDetector.OnGestureListener'yi geçersiz kılarak uygulayabilirsiniz. Sürükleme hakkında daha fazla bilgi için Sürükleme ve ölçeklendirme başlıklı makaleyi inceleyin.
  • Fırlatma: Bu, kullanıcının parmağını hızlıca sürükleyip kaldırdığında gerçekleşen kaydırma türüdür. Kullanıcı parmağını kaldırdıktan sonra, genellikle görüntü alanını hareket ettirmeye devam etmek istersiniz ancak görüntü alanı durana kadar yavaşlatırsınız. onFling() içinde GestureDetector.OnGestureListener öğesini geçersiz kılarak ve bir kaydırma nesnesi kullanarak kaydırma hareketini uygulayabilirsiniz.
  • Kaydırma: Hem x hem de y eksenlerinde aynı anda kaydırmaya kaydırma denir.

Kaydırma hareketleriyle birlikte kaydırma nesneleri kullanmak yaygındır ancak kullanıcı arayüzünün dokunma etkinliğine yanıt olarak kaydırma göstermesini istediğiniz her bağlamda bunları kullanabilirsiniz. Örneğin, dokunma etkinliklerini doğrudan işlemek ve bu dokunma etkinliklerine yanıt olarak kaydırma efekti veya "sayfaya tutturma" animasyonu oluşturmak için geçersiz kılabilirsiniz. onTouchEvent()

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

Aşağıdaki Android bileşenleri, kaydırma ve aşırı kaydırma davranışları için yerleşik destek içerir:

Uygulamanızın farklı bir bileşende kaydırma ve aşırı kaydırmayı desteklemesi gerekiyorsa aşağıdaki adımları tamamlayın:

  1. Özel dokunmaya dayalı kaydırma uygulaması oluşturun.
  2. Android 12 ve sonraki sürümleri çalıştıran cihazları desteklemek için esnetme kaydırma efektini uygulayın.

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

Bu bölümde, uygulamanızda kaydırma ve aşırı kaydırma için yerleşik destek içermeyen bir bileşen kullanılıyorsa kendi kaydırma çubuğunuzu nasıl oluşturacağınız açıklanmaktadır.

Aşağıdaki snippet, InteractiveChart örneğinden alınmıştır. GestureDetector kullanır ve GestureDetector.SimpleOnGestureListener yöntemini onFling() geçersiz kılar. Bu özellik, fırlatma hareketini izlemek için OverScroller kullanır. Kullanıcı, kaydırma hareketini yaptıktan sonra içerik kenarlarına ulaşırsa kapsayıcı, kullanıcının içeriğin sonuna ulaştığını belirtir. Gösterge, cihazda çalışan Android sürümüne bağlıdır:

  • Android 12 ve sonraki sürümlerde görsel öğeler uzar ve geri döner.
  • Android 11 ve önceki sürümlerde görsel öğeler parıltı efektiyle gösterilir.

Aşağıdaki snippet'in ilk bölümünde onFling() öğesinin uygulanması gösterilmektedir:

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

onFling(), postInvalidateOnAnimation() işlevini çağırdığında computeScroll() işlevi tetiklenerek x ve y değerleri güncellenir. Bu işlem genellikle, önceki örnekte gösterildiği gibi, bir görünüm alt öğesi kaydırma nesnesi kullanarak kaydırmayı animasyonla gösterdiğinde yapılır.

Görünümlerin çoğu, kaydırma nesnesinin x ve y konumunu doğrudan scrollTo()'ye iletir. computeScroll()'nın aşağıdaki uygulaması farklı bir yaklaşım kullanır: x ve y'nin mevcut konumunu almak için computeScrollOffset()'u çağırır. Aşırı kaydırma "parıltı" kenar efektinin gösterilmesi için gereken ölçütler karşılandığında (ör. ekran yakınlaştırılmış, x veya y sınırların dışında ve uygulama zaten aşırı kaydırma göstermiyor) kod, aşırı kaydırma parıltı efektini ayarlar ve görünümde geçersiz kılmayı tetiklemek için postInvalidateOnAnimation() işlevini çağırır.

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

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

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

Bu, önceki snippet'te çağrılan computeScrollSurfaceSize() yöntemidir. Mevcut kaydırılabilir yüzey boyutunu piksel cinsinden hesaplar. Örneğin, grafik alanının tamamı görünür durumdaysa bu, mContentRect öğesinin mevcut boyutudur. Grafik her iki yönde de% 200 yakınlaştırılırsa döndürülen boyut yatay ve dikey olarak iki kat daha büyük olur.

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

Kaydırma çubuğu kullanımına ilişkin başka bir örnek için ViewPager sınıfının kaynak koduna bakın. Kaydırma hareketlerine yanıt olarak kaydırılır ve "sayfaya tutturma" animasyonunu uygulamak için kaydırma kullanılır.

Kaydırma sonu esneme efektini uygulama

Android 12'den itibaren EdgeEffect, esnetme kaydırma efektini uygulamak için aşağıdaki API'leri ekler:

  • getDistance()
  • onPullDistance()

Esnek kaydırma ile en iyi kullanıcı deneyimini sunmak için aşağıdakileri yapın:

  1. Kullanıcı içeriğe dokunduğunda esnetme animasyonu etkinse dokunmayı "yakalama" olarak kaydedin. Kullanıcı animasyonu durdurur ve esnetme işlemini tekrar başlatır.
  2. Kullanıcı parmağını uzatmanın tersi yönde hareket ettirdiğinde, uzatma tamamen kaybolana kadar bırakın ve ardından kaydırmaya başlayın.
  3. Kullanıcı esneme sırasında fırlatma işlemi yaptığında esneme efektini artırmak için EdgeEffect simgesini fırlatın.

Animasyonu yakalama

Kullanıcı etkin bir esneme animasyonu yakaladığında EdgeEffect.getDistance() döndürülür.0 Bu koşul, esnetmenin dokunma hareketiyle değiştirilmesi gerektiğini gösterir. Çoğu kapsayıcıda, aşağıdaki kod snippet'inde gösterildiği gibi, yakalama onInterceptTouchEvent() içinde algılanır:

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

Önceki örnekte, mIsBeingDragged true olduğunda onInterceptTouchEvent() true değerini döndürür. Bu nedenle, çocuk etkinliği kullanma fırsatı bulmadan önce etkinliği kullanmak yeterlidir.

Kaydırma sonu efektini bırakma

Kaydırma işlemine başlamadan önce esneme efektini serbest bırakmak, esnemenin kaydırılan içeriğe uygulanmasını önlemek için önemlidir. Aşağıdaki kod örneğinde bu en iyi uygulama uygulanmaktadır:

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

Kullanıcı sürükleme işlemi yaparken dokunma etkinliğini iç içe yerleştirilmiş bir kaydırma kapsayıcısına iletmeden veya kaydırmayı sürüklemeden önce EdgeEffectçekme mesafesini tüketin. Önceki kod örneğinde, getDistance(), kenar efekti gösterilirken pozitif bir değer döndürür ve hareketle serbest bırakılabilir. Dokunma etkinliği esnetmeyi bıraktığında, diğer efektler (ör. iç içe kaydırma) görüntülenmeden önce tamamen bırakılması için önce EdgeEffect tarafından tüketilir. Mevcut efekti serbest bırakmak için ne kadar çekme mesafesi gerektiğini öğrenmek üzere getDistance() simgesini kullanabilirsiniz.

onPull() işlevinden farklı olarak onPullDistance(), iletilen delta değerinin tüketilen tutarını döndürür. Android 12'den itibaren, getDistance() değeri 0 olduğunda onPull() veya onPullDistance() için negatif deltaDistance değerler iletilirse esneme efekti değişmez. Android 11 ve önceki sürümlerde onPull(), toplam mesafenin negatif değerlerinin parıltı efektleri göstermesine olanak tanır.

Kaydırma sonu davranışını devre dışı bırakma

Overscroll'u düzen dosyanızda veya programatik olarak devre dışı bırakabilirsiniz.

Düzen dosyanızda bu özelliği devre dışı bırakmak için android:overScrollMode özelliğini aşağıdaki örnekte gösterildiği gibi ayarlayın:

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

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

Kotlin

customView.overScrollMode = View.OVER_SCROLL_NEVER

Java

customView.setOverScrollMode(View.OVER_SCROLL_NEVER);

Ek kaynaklar

Aşağıdaki ilgili kaynaklara göz atın: