Kaydırma hareketini canlandırma

Oluşturma yöntemini deneyin

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

Kaydırma →

Android'de kaydırma işlemi genellikle ScrollView sınıfı kullanılarak yapılır. Çerçeve tarafından yönetilen kaydırılabilir bir görünüm sağlamak için kapsayıcısının sınırlarının ötesine geçebilecek tüm standart düzenleri bir ScrollView içine yerleştirin. Özel kaydırma çubuğu uygulamak yalnızca özel senaryolar için gereklidir. Bu dokümanda, kaydırma çubukları kullanılarak dokunma hareketlerine yanıt olarak kaydırma efektinin nasıl gösterileceği açıklanmaktadır.

Uygulamanız, bir dokunma etkinliğine yanıt olarak kaydırma animasyonu oluşturmak için gereken verileri toplamak üzere kaydırma çubuğu (Scroller veya OverScroller) kullanabilir. Bu iki yöntem benzerdir ancak OverScroller, kaydırma veya fırlatma hareketinden sonra kullanıcılara içerik kenarlarına ulaştıklarında bunu bildirme yöntemleri de içerir.

• Android 12'den (API düzeyi 31) itibaren, görsel öğeler bir sürükleme etkinliğinde uzar ve geri sıçrar, bir fırlatma etkinliğinde ise uzar ve geri sıçrar.
• Android 11 (API düzeyi 30) ve önceki sürümlerde, kenara doğru sürükleme veya fırlatma hareketi yapıldıktan sonra kenarlıklar "parlama" efekti gösterir.

Bu dokümandaki InteractiveChart örneği, bu kaydırma efektlerini göstermek için EdgeEffect sınıfını kullanır.

Platform standardı kaydırma fiziği (ör. sürtünme, hız ve diğer özellikler) kullanarak kaydırma işlemini zaman içinde animasyonlu hale getirmek için kaydırma çubuğu kullanabilirsiniz. Kaydırma çubuğunun kendisi hiçbir şey çizmez. Kaydırma çubuğu, kaydırma ofsetlerini zaman içinde sizin için izler ancak bu konumları görünümünüze otomatik olarak uygulamaz. Kaydırma animasyonunun düzgün görünmesini sağlayacak bir hızda yeni koordinatlar alıp uygulamanız gerekir.

Kaydırma terminolojisini anlama

Kaydırma, bağlama bağlı olarak Android'de farklı anlamlara gelebilir.

Kaydırma, ekran görüntüsünü (yani, baktığınız içeriğin "penceresini") taşıma işlemidir. Hem x hem de y eksenlerinde kaydırma yapıldığında buna yakınlaştırma/uzaklaştırma denir. Bu dokümanda yer alan InteractiveChart örnek uygulamada, iki farklı kaydırma, sürükleme ve fırlatma türü gösterilmektedir:

• Sürükleme: Kullanıcı parmağını dokunmatik ekranda sürüklediğinde gerçekleşen kaydırma türüdür. GestureDetector.OnGestureListener içinde onScroll() değerini geçersiz kılarak sürüklemeyi uygulayabilirsiniz. Sürükleme hakkında daha fazla bilgi için Sürükle ve ölçeklendir başlıklı makaleyi inceleyin.
• Fırlatma: Kullanıcı parmağını hızlıca sürüp 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ı hareket etmeyi durdurana kadar hızınızı düşürürsünüz. GestureDetector.OnGestureListener içinde onFling() değerini geçersiz kılarak ve bir kaydırma nesnesi kullanarak fırlatma özelliğini uygulayabilirsiniz.
• Kaydırma: Hem x hem de y eksenlerinde aynı anda kaydırmaya kaydırma denir.

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

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

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

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

Uygulamanızın farklı bir bileşen içinde kaydırma ve aşırı kaydırma özelliğini desteklemesi gerekiyorsa aşağıdaki adımları uygulayın:

1. Dokunmaya dayalı özel bir kaydırma uygulaması oluşturun.
2. Android 12 ve sonraki sürümleri çalıştıran cihazları desteklemek için uzatılmış kaydırma efektini uygulayın.

Dokunmaya dayalı özel bir kaydırma uygulaması oluşturma

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

Aşağıdaki snippet, InteractiveChart örnek dosyasından alınmıştır. Bir GestureDetector kullanır ve GestureDetector.SimpleOnGestureListener yönteminin onFling() parametresini geçersiz kılar. Parmak ucunu kaydırma hareketini izlemek için OverScroller kullanılır. Kullanıcı, kaydırma hareketini gerçekleştirdikten sonra içeriğin kenarlarına ulaşırsa kapsayıcı, kullanıcının içeriğin sonuna ulaştığını gösterir. Bu gösterge, cihazın kullandığı 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 parlama efekti gösterir.

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

// 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(), postInvalidateOnAnimation()'u çağrdığında computeScroll(), x ve y değerlerini güncellemek için tetiklenir. Bu işlem genellikle, önceki örnekte gösterildiği gibi bir görünüm alt öğesi bir kaydırma nesnesi kullanarak kaydırma animasyonu yaparken yapılır.

Çoğu görünüm, kaydırma çubuğu nesnesinin x ve y konumunu doğrudan scrollTo()'ye iletir. Aşağıdaki computeScroll() uygulaması farklı bir yaklaşım benimser: x ve y'nin mevcut konumunu almak için computeScrollOffset()'ı çağırır. Ekran kaydırma "parlama" kenar efektinin gösterilmesiyle ilgili ölçütler karşılandığında (yani ekran yakınlaştırılmışsa, x veya y sınırların dışındaysa ve uygulamada ekran kaydırma zaten gösterilmiyorsa) kod, ekran kaydırma parlama efektini ayarlar ve görünümde geçersiz kılma işlemini tetiklemek için postInvalidateOnAnimation()'yi çağırır.

// 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ırmayı 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);
}

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üyorsa bu, mContentRect öğesinin mevcut boyutudur. Grafik her iki yönde de% 200 oranında yakınlaştırılırsa 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ğunun kullanıldığı başka bir örnek için ViewPager sınıfının kaynak koduna bakın. Parmak ucuyla kaydırmaya yanıt olarak kaydırılır ve "sayfaya sabitleme" animasyonunu uygulamak için kaydırma işlemini kullanır.

Kaydırma sırasında uzay efekti uygulama

Android 12'den itibaren EdgeEffect, aşırı kaydırma sırasında uzatma efektini uygulamak için aşağıdaki API'leri ekler:

• getDistance()
• onPullDistance()

Uzatma kaydırma özelliğiyle en iyi kullanıcı deneyimini sunmak için aşağıdakileri yapın:

1. Kullanıcı içeriğe dokunduğunda esneme animasyonu etkinse dokunuşu "yakalama" olarak kaydedin. Kullanıcı animasyonu durdurur ve tekrar esnemeyi değiştirmeye başlar.
2. Kullanıcı parmağını esnetmenin ters yönünde hareket ettirdiğinde, esnetmeyi tamamen kaldırana kadar bekleyin ve ardından kaydırmaya başlayın.
3. Kullanıcı bir esneme sırasında parmağını kaydırdığında, esneme efektini artırmak için EdgeEffect simgesini kaydırın.

Animasyonu yakalama

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

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

Önceki örnekte, mIsBeingDragged true olduğunda onInterceptTouchEvent() true döndürür. Bu nedenle, alt öğenin etkinliği kullanma fırsatı bulamadan önce etkinliği kullanmak yeterlidir.

Kaydırma sonu efektini bırakma

Uzatma efektinin kaydırılan içeriğe uygulanmasını önlemek için kaydırmadan önce uzatma efektini kaldırmak önemlidir. Aşağıdaki kod örneğinde bu en iyi uygulama uygulanmaktadır:

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 dokunma etkinliğini iç içe yerleştirilmiş bir kaydırma kapsayıcısına iletmeden veya kaydırma çubuğunu 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, esnemeyi bıraktığında önce EdgeEffect tarafından tüketilir. Böylece, iç içe kaydırma gibi diğer efektler gösterilmeden önce tamamen bırakılır. Mevcut efekti kaldırmak için ne kadar çekme mesafesi gerektiğini öğrenmek üzere getDistance() simgesini kullanabilirsiniz.

onPull()'ün aksine onPullDistance(), iletilen deltanın tüketilen tutarını döndürür. Android 12'den itibaren, getDistance() 0 olduğunda onPull() veya onPullDistance()'ye negatif deltaDistance değerleri iletilirse esneme efekti değişmez. Android 11 ve önceki sürümlerde onPull(), toplam mesafenin negatif değerlerinin parlama efektleri göstermesine olanak tanır.

Ekranın aşırı kaydırılmasını devre dışı bırakma

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

Bu özelliği sayfa düzeni dosyanızda devre dışı bırakmak için android:overScrollMode değerini aşağıdaki örnekte gösterildiği gibi ayarlayın:

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

Programlı olarak kapsam dışında kalmayı tercih etmek 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ümleri etkileşimli hale getirme