একটি স্ক্রোল অঙ্গভঙ্গি অ্যানিমেট

রচনা পদ্ধতি চেষ্টা করুন

জেটপ্যাক কম্পোজ হল Android এর জন্য প্রস্তাবিত UI টুলকিট। কম্পোজে কীভাবে স্পর্শ এবং ইনপুট ব্যবহার করবেন তা শিখুন।

স্ক্রোলিং →

অ্যান্ড্রয়েডে, স্ক্রোলিং সাধারণত ScrollView ক্লাস ব্যবহার করে অর্জন করা হয়। ফ্রেমওয়ার্ক দ্বারা পরিচালিত একটি স্ক্রোলযোগ্য ভিউ প্রদানের জন্য একটি ScrollView -তে এর কন্টেইনারের সীমানা ছাড়িয়ে প্রসারিত হতে পারে এমন যেকোনো মানক লেআউট নেস্ট করুন। একটি কাস্টম স্ক্রোলার প্রয়োগ করা শুধুমাত্র বিশেষ পরিস্থিতির জন্য প্রয়োজনীয়। এই ডকুমেন্টটি বর্ণনা করে কিভাবে স্ক্রোলার ব্যবহার করে স্পর্শ অঙ্গভঙ্গির প্রতিক্রিয়ায় একটি স্ক্রলিং প্রভাব প্রদর্শন করতে হয়।

একটি স্পর্শ ইভেন্টের প্রতিক্রিয়া হিসাবে একটি স্ক্রলিং অ্যানিমেশন তৈরি করার জন্য প্রয়োজনীয় ডেটা সংগ্রহ করতে আপনার অ্যাপ স্ক্রলার— Scroller বা OverScroller — ব্যবহার করতে পারে৷ এগুলি একই রকম, তবে OverScroller ব্যবহারকারীদের নির্দেশ করার পদ্ধতিগুলিও অন্তর্ভুক্ত করে যখন তারা একটি প্যান বা ফ্লিং অঙ্গভঙ্গির পরে বিষয়বস্তুর প্রান্তে পৌঁছায়।

• অ্যান্ড্রয়েড 12 (API লেভেল 31) থেকে শুরু করে, ভিজ্যুয়াল উপাদানগুলি একটি ড্র্যাগ ইভেন্টে প্রসারিত এবং বাউন্স ব্যাক করে এবং ফ্লিং ইভেন্টে ফ্লিং এবং বাউন্স ব্যাক করে।
• অ্যান্ড্রয়েড 11 (এপিআই লেভেল 30) এবং তার আগে, প্রান্তে টেনে আনা বা ফ্লিং ইঙ্গিত করার পরে সীমানা একটি "গ্লো" প্রভাব প্রদর্শন করে।

এই নথিতে InteractiveChart নমুনা এই ওভারস্ক্রোল প্রভাবগুলি প্রদর্শন করতে EdgeEffect ক্লাস ব্যবহার করে।

প্ল্যাটফর্ম-স্ট্যান্ডার্ড স্ক্রোলিং পদার্থবিদ্যা যেমন ঘর্ষণ, বেগ এবং অন্যান্য গুণাবলী ব্যবহার করে আপনি সময়ের সাথে স্ক্রোলিংকে অ্যানিমেট করতে একটি স্ক্রলার ব্যবহার করতে পারেন। স্ক্রলার নিজেই কিছু আঁকে না। স্ক্রোলারগুলি সময়ের সাথে সাথে আপনার জন্য স্ক্রোল অফসেটগুলি ট্র্যাক করে, কিন্তু তারা স্বয়ংক্রিয়ভাবে সেই অবস্থানগুলি আপনার দৃশ্যে প্রয়োগ করে না। আপনাকে অবশ্যই এমন একটি হারে নতুন স্থানাঙ্ক পেতে এবং প্রয়োগ করতে হবে যা স্ক্রলিং অ্যানিমেশনটিকে মসৃণ দেখায়।

স্ক্রলিং পরিভাষা বুঝুন

স্ক্রোলিং এমন একটি শব্দ যা প্রেক্ষাপটের উপর নির্ভর করে অ্যান্ড্রয়েডে বিভিন্ন জিনিস বোঝাতে পারে।

স্ক্রলিং হল ভিউপোর্ট সরানোর সাধারণ প্রক্রিয়া—অর্থাৎ, আপনি যে বিষয়বস্তু দেখছেন তার "উইন্ডো"৷ যখন স্ক্রলিং x - এবং y - অক্ষ উভয় ক্ষেত্রেই থাকে, তখন একে প্যানিং বলে। এই নথিতে InteractiveChart নমুনা অ্যাপটি দুটি ভিন্ন ধরনের স্ক্রলিং, টেনে আনা এবং ফ্লিং করার চিত্র তুলে ধরে:

• টেনে আনা: এটি এমন একটি স্ক্রলিং যা ঘটে যখন একজন ব্যবহারকারী তাদের আঙুল টাচস্ক্রিন জুড়ে টেনে আনে। আপনি GestureDetector.OnGestureListener এ onScroll() ওভাররাইড করে ড্র্যাগিং বাস্তবায়ন করতে পারেন। টেনে আনার বিষয়ে আরও তথ্যের জন্য, টেনে আনুন এবং স্কেল দেখুন।
• ফ্লিংিং: এটি এমন একটি স্ক্রলিং যা ঘটে যখন একজন ব্যবহারকারী তাদের আঙুল দ্রুত টেনে নিয়ে যায়। ব্যবহারকারী তার আঙুল তুলে নেওয়ার পরে, আপনি সাধারণত ভিউপোর্টটি সরাতে চান, কিন্তু যতক্ষণ না ভিউপোর্টটি নড়াচড়া করা বন্ধ হয়ে যায় ততক্ষণ গতি কমিয়ে দিন। আপনি GestureDetector.OnGestureListener এ onFling() ওভাররাইড করে এবং একটি স্ক্রলার অবজেক্ট ব্যবহার করে ফ্লিংিং বাস্তবায়ন করতে পারেন।
• প্যানিং: x - এবং y -অক্ষ উভয় বরাবর একই সাথে স্ক্রল করাকে প্যানিং বলে।

ফ্লিং ইঙ্গিতের সাথে স্ক্রলার অবজেক্টগুলি ব্যবহার করা সাধারণ, তবে আপনি যেকোন প্রেক্ষাপটে সেগুলি ব্যবহার করতে পারেন যেখানে আপনি স্পর্শ ইভেন্টের প্রতিক্রিয়া হিসাবে UI স্ক্রলিং প্রদর্শন করতে চান৷ উদাহরণস্বরূপ, আপনি স্পর্শ ইভেন্টগুলি সরাসরি প্রক্রিয়া করতে এবং একটি স্ক্রলিং প্রভাব বা সেই স্পর্শ ইভেন্টগুলির প্রতিক্রিয়া হিসাবে একটি "স্ন্যাপ-টু-পৃষ্ঠা" অ্যানিমেশন তৈরি করতে onTouchEvent() ওভাররাইড করতে পারেন৷

অন্তর্নির্মিত স্ক্রোলিং বাস্তবায়ন ধারণ করে এমন উপাদান

নিম্নলিখিত Android উপাদানগুলিতে স্ক্রলিং এবং ওভারস্ক্রলিং আচরণের জন্য অন্তর্নির্মিত সমর্থন রয়েছে:

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

যদি আপনার অ্যাপটিকে একটি ভিন্ন উপাদানের ভিতরে স্ক্রলিং এবং ওভারস্ক্রলিং সমর্থন করতে হয়, তাহলে নিম্নলিখিত পদক্ষেপগুলি সম্পূর্ণ করুন:

1. একটি কাস্টম স্পর্শ-ভিত্তিক স্ক্রোলিং বাস্তবায়ন তৈরি করুন ।
2. অ্যান্ড্রয়েড 12 এবং পরবর্তীতে চালিত ডিভাইসগুলিকে সমর্থন করতে, স্ট্রেচ ওভারস্ক্রোল প্রভাব প্রয়োগ করুন ৷

একটি কাস্টম স্পর্শ-ভিত্তিক স্ক্রোলিং বাস্তবায়ন তৈরি করুন

এই বিভাগটি বর্ণনা করে যে কীভাবে আপনার নিজের স্ক্রোলার তৈরি করবেন যদি আপনার অ্যাপ এমন একটি উপাদান ব্যবহার করে যাতে স্ক্রলিং এবং ওভারস্ক্রোলিংয়ের জন্য অন্তর্নির্মিত সমর্থন নেই।

নিম্নলিখিত স্নিপেটটি InteractiveChart নমুনা থেকে এসেছে। এটি একটি GestureDetector ব্যবহার করে এবং GestureDetector.SimpleOnGestureListener পদ্ধতি onFling() ওভাররাইড করে। এটি ফ্লিং অঙ্গভঙ্গি ট্র্যাক করতে OverScroller ব্যবহার করে। যদি ব্যবহারকারী ফ্লিং অঙ্গভঙ্গি সম্পাদন করার পরে বিষয়বস্তুর প্রান্তে পৌঁছায়, তাহলে ধারকটি নির্দেশ করে যে ব্যবহারকারী কখন বিষয়বস্তুর শেষে পৌঁছেছেন। ইঙ্গিতটি Android এর সংস্করণের উপর নির্ভর করে যা একটি ডিভাইস চালায়:

• Android 12 এবং পরবর্তীতে, ভিজ্যুয়াল উপাদানগুলি প্রসারিত হয় এবং ফিরে আসে।
• অ্যান্ড্রয়েড 11 এবং তার আগের, ভিজ্যুয়াল উপাদানগুলি একটি উজ্জ্বল প্রভাব প্রদর্শন করে।

নিম্নলিখিত স্নিপেটের প্রথম অংশ 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() postInvalidateOnAnimation() কল করে, তখন এটি x এবং y- এর মান আপডেট করতে computeScroll() ট্রিগার করে। এটি সাধারণত করা হয় যখন একটি ভিউ শিশু একটি স্ক্রলার অবজেক্ট ব্যবহার করে একটি স্ক্রোল অ্যানিমেট করে, যেমনটি পূর্বের উদাহরণে দেখানো হয়েছে।

বেশিরভাগ ভিউ স্ক্রলার অবজেক্টের x এবং y অবস্থানকে সরাসরি scrollTo() এ পাস করে। computeScroll() এর নিম্নলিখিত বাস্তবায়ন একটি ভিন্ন পদ্ধতি গ্রহণ করে: এটি x এবং y এর বর্তমান অবস্থান পেতে computeScrollOffset() কল করে। যখন একটি ওভারস্ক্রোল "গ্লো" এজ ইফেক্ট প্রদর্শনের মাপকাঠি পূরণ করা হয়—অর্থাৎ, ডিসপ্লে জুম করা হয়, x বা y সীমার বাইরে থাকে, এবং অ্যাপটি ইতিমধ্যেই কোনো ওভারস্ক্রোল দেখাচ্ছে না—কোডটি ওভারস্ক্রোল গ্লো সেট আপ করে ইফেক্ট এবং কল করে postInvalidateOnAnimation() ভিউতে একটি অবৈধ ট্রিগার করতে।

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

এখানে কোডের বিভাগটি যা প্রকৃত জুম সম্পাদন করে:

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() পদ্ধতি যা পূর্ববর্তী স্নিপেটে বলা হয়েছে। এটি পিক্সেলে বর্তমান স্ক্রোলযোগ্য পৃষ্ঠের আকার গণনা করে। উদাহরণস্বরূপ, যদি সমগ্র চার্ট এলাকাটি দৃশ্যমান হয়, এটি mContentRect এর বর্তমান আকার। যদি চার্টটি উভয় দিকে 200% জুম করা হয়, তাহলে প্রত্যাবর্তিত আকারটি অনুভূমিকভাবে এবং উল্লম্বভাবে দ্বিগুণ বড় হয়।

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

স্ক্রোলার ব্যবহারের আরেকটি উদাহরণের জন্য, ViewPager ক্লাসের সোর্স কোড দেখুন। এটি ফ্লিংয়ের প্রতিক্রিয়া হিসাবে স্ক্রোল করে এবং "স্ন্যাপ-টু-পেজ" অ্যানিমেশন বাস্তবায়নের জন্য স্ক্রলিং ব্যবহার করে।

প্রসারিত ওভারস্ক্রোল প্রভাব প্রয়োগ করুন

অ্যান্ড্রয়েড 12 থেকে শুরু করে, EdgeEffect স্ট্রেচ ওভারস্ক্রোল প্রভাব বাস্তবায়নের জন্য নিম্নলিখিত API যোগ করে:

• getDistance()
• onPullDistance()

স্ট্রেচ ওভারস্ক্রোল সহ সর্বোত্তম ব্যবহারকারীর অভিজ্ঞতা প্রদান করতে, নিম্নলিখিতগুলি করুন:

1. যখন প্রসারিত অ্যানিমেশন কার্যকর হয় যখন ব্যবহারকারী বিষয়বস্তু স্পর্শ করে, স্পর্শটিকে "ক্যাচ" হিসাবে নিবন্ধন করুন। ব্যবহারকারী অ্যানিমেশন বন্ধ করে এবং আবার প্রসারিত ম্যানিপুলেট করা শুরু করে।
2. যখন ব্যবহারকারী তাদের আঙুলটি স্ট্রেচের বিপরীত দিকে নিয়ে যান, প্রসারিতটি সম্পূর্ণরূপে চলে না যাওয়া পর্যন্ত ছেড়ে দিন এবং তারপরে স্ক্রোল করা শুরু করুন।
3. যখন ব্যবহারকারী স্ট্রেচের সময় ফ্লিং করে, তখন স্ট্রেচ ইফেক্ট বাড়ানোর জন্য EdgeEffect ফ্লিং করুন।

অ্যানিমেশন ধরুন

যখন একজন ব্যবহারকারী একটি সক্রিয় স্ট্রেচ অ্যানিমেশন ধরেন, EdgeEffect.getDistance() 0 প্রদান করে। এই শর্তটি নির্দেশ করে যে প্রসারিতটি স্পর্শ গতি দ্বারা ম্যানিপুলেট করা আবশ্যক। বেশিরভাগ পাত্রে, ক্যাচটি onInterceptTouchEvent() এ সনাক্ত করা হয়, যেমনটি নিম্নলিখিত কোড স্নিপেটে দেখানো হয়েছে:

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

পূর্ববর্তী উদাহরণে, onInterceptTouchEvent() true ফেরত দেয় যখন mIsBeingDragged true হয়, তাই শিশুর এটি গ্রহণ করার সুযোগ পাওয়ার আগে ইভেন্টটি গ্রহণ করা যথেষ্ট।

ওভারস্ক্রোল প্রভাব প্রকাশ করুন

স্ক্রোলিং বিষয়বস্তুতে প্রসারিত হওয়া রোধ করার জন্য স্ক্রল করার আগে স্ট্রেচ ইফেক্টটি ছেড়ে দেওয়া গুরুত্বপূর্ণ। নিম্নলিখিত কোড নমুনা এই সেরা অনুশীলন প্রয়োগ করে:

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

ব্যবহারকারী যখন টেনে আনছেন, তখন আপনি স্পর্শ ইভেন্টটি নেস্টেড স্ক্রলিং কন্টেনারে পাস করার আগে বা স্ক্রোলটি টেনে আনতে EdgeEffect পুল দূরত্বটি ব্যবহার করুন। পূর্ববর্তী কোড নমুনায়, getDistance() একটি ইতিবাচক মান প্রদান করে যখন একটি প্রান্ত প্রভাব প্রদর্শিত হচ্ছে এবং গতির সাথে মুক্তি দেওয়া যেতে পারে। যখন টাচ ইভেন্ট স্ট্রেচ রিলিজ করে, তখন এটি প্রথমে EdgeEffect দ্বারা গ্রাস করা হয় যাতে অন্যান্য প্রভাব যেমন নেস্টেড স্ক্রোলিং প্রদর্শিত হওয়ার আগে এটি সম্পূর্ণরূপে মুক্তি পায়। বর্তমান প্রভাব প্রকাশ করার জন্য কতটা টান দূরত্ব প্রয়োজন তা জানতে আপনি getDistance() ব্যবহার করতে পারেন।

onPull() বিপরীতে, onPullDistance() পাস করা ব-দ্বীপের খরচকৃত পরিমাণ ফেরত দেয়। Android 12 থেকে শুরু করে, যদি getDistance() 0 হলে onPull() বা onPullDistance() নেতিবাচক deltaDistance মান পাস করা হয়, প্রসারিত প্রভাব পরিবর্তন হয় না। অ্যান্ড্রয়েড 11 এবং তার আগে, onPull() মোট দূরত্বের জন্য নেতিবাচক মানগুলিকে গ্লো ইফেক্ট দেখাতে দেয়।

ওভারস্ক্রোল থেকে অপ্ট আউট করুন

আপনি আপনার লেআউট ফাইলে বা প্রোগ্রামগতভাবে ওভারস্ক্রোল থেকে অপ্ট আউট করতে পারেন।

আপনার লেআউট ফাইলে অপ্ট আউট করতে, নিম্নলিখিত উদাহরণে দেখানো হিসাবে android:overScrollMode সেট করুন:

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

প্রোগ্রামগতভাবে অপ্ট আউট করতে, নিম্নলিখিত মত কোড ব্যবহার করুন:

customView.overScrollMode = View.OVER_SCROLL_NEVER

customView.setOverScrollMode(View.OVER_SCROLL_NEVER);

অতিরিক্ত সম্পদ

নিম্নলিখিত সম্পর্কিত সংস্থান পড়ুন:

• ইনপুট ইভেন্ট ওভারভিউ
• সেন্সর ওভারভিউ
• একটি কাস্টম ভিউ ইন্টারেক্টিভ করুন