Android में Viewpager नियंत्रक की धीमी गति

Question

क्या android में viewpager अनुकूलक के साथ स्क्रॉल गति को धीमा करने का कोई तरीका है?

---

तुम्हें पता है, मैं इस कोड को देख रहा हूं। मैं यह पता नहीं लगा सकता कि मैं क्या गलत हूं।

try{ 
    Field mScroller = mPager.getClass().getDeclaredField("mScroller"); 
    mScroller.setAccessible(true); 
    Scroller scroll = new Scroller(cxt);
    Field scrollDuration = scroll.getClass().getDeclaredField("mDuration");
    scrollDuration.setAccessible(true);
    scrollDuration.set(scroll, 1000);
    mScroller.set(mPager, scroll);
}catch (Exception e){
    Toast.makeText(cxt, "something happened", Toast.LENGTH_LONG).show();
} 

यह कुछ भी नहीं बदलता है फिर भी कोई अपवाद नहीं होता है?

Comments

इस antoniocappiello.com/2015/10/31/… पर

— अयप्पा

child.setNestedScrollingEnabled(false);मेरे लिए काम किया

— पियरे

Answer 1

मैंने HighFlyer के कोड के साथ शुरुआत की है जो वास्तव में mScroller फ़ील्ड को बदल दिया है (जो कि एक शानदार शुरुआत है) लेकिन स्क्रॉल की अवधि बढ़ाने में मदद नहीं की क्योंकि ViewPager स्क्रॉल करने का अनुरोध करते समय स्पष्ट रूप से mScroller की अवधि पास करता है।

महत्वपूर्ण विधि (smoothScrollTo) के रूप में दृश्यदर्शी को विस्तारित करने से काम नहीं किया जा सकता है।

मैंने इस कोड के साथ स्कोरर का विस्तार करके इसे ठीक किया:

public class FixedSpeedScroller extends Scroller {

    private int mDuration = 5000;

    public FixedSpeedScroller(Context context) {
        super(context);
    }

    public FixedSpeedScroller(Context context, Interpolator interpolator) {
        super(context, interpolator);
    }

    public FixedSpeedScroller(Context context, Interpolator interpolator, boolean flywheel) {
        super(context, interpolator, flywheel);
    }


    @Override
    public void startScroll(int startX, int startY, int dx, int dy, int duration) {
        // Ignore received duration, use fixed one instead
        super.startScroll(startX, startY, dx, dy, mDuration);
    }

    @Override
    public void startScroll(int startX, int startY, int dx, int dy) {
        // Ignore received duration, use fixed one instead
        super.startScroll(startX, startY, dx, dy, mDuration);
    }
}

और इसे इस तरह से उपयोग करना:

try {
    Field mScroller;
    mScroller = ViewPager.class.getDeclaredField("mScroller");
    mScroller.setAccessible(true); 
    FixedSpeedScroller scroller = new FixedSpeedScroller(mPager.getContext(), sInterpolator);
    // scroller.setFixedDuration(5000);
    mScroller.set(mPager, scroller);
} catch (NoSuchFieldException e) {
} catch (IllegalArgumentException e) {
} catch (IllegalAccessException e) {
}

मैंने मूल रूप से 5 सेकंड की अवधि को हार्डकोड किया है और मेरे ViewPager का उपयोग किया है।

उम्मीद है की यह मदद करेगा।

Comments

क्या आप मुझे बता सकते हैं कि sInterpolator क्या है ??

— शशांक दिग्लूरकर

'इंटरपोलर' वह दर है जिस पर एनिमेशन चलाए जाते हैं, उदाहरण के लिए वे तेजी, मंदी, और बहुत कुछ कर सकते हैं। एक इंटरपोलर के बिना एक कंस्ट्रक्टर है, मुझे लगता है कि काम करना चाहिए, इसलिए कॉल से उस तर्क को हटाने की कोशिश करें। अगर वह काम नहीं करता है, तो जोड़ें: 'Interpolator sInterpolator = new AccelerateInterpolator ()'

— marmor

मैंने पाया कि DecelerateInterpolator इस मामले में बेहतर काम करता है, यह शुरुआती कड़ी चोट की गति को बनाए रखता है और फिर धीरे-धीरे कम हो जाता है।

— क्विंट स्टॉफ़र्स

नमस्ते, क्या आपके पास कोई विचार scroller.setFixedDuration(5000);है जो एक त्रुटि देता है? यह कहता है "विधि सेटफिक्सडिडेशन (int) अपरिभाषित है"

— jaibatrik

अगर आप proguard का उपयोग कर रहे हैं तो इस लाइन को जोड़ना न भूलें:--class class android.support.v4। ** {*;} अन्यथा आप getDeclaredField ()

— GuilhE

Answer 2

मैं खुद करना चाहता हूं और एक समाधान प्राप्त किया है (हालांकि, प्रतिबिंब का उपयोग करके)। यह स्वीकृत समाधान के समान है लेकिन समान प्रक्षेपक का उपयोग करता है और केवल एक कारक के आधार पर अवधि बदलता है। आपको ViewPagerCustomDurationइसके बजाय अपने XML में एक का उपयोग करने की आवश्यकता है ViewPager, और फिर आप यह कर सकते हैं:

ViewPagerCustomDuration vp = (ViewPagerCustomDuration) findViewById(R.id.myPager);
vp.setScrollDurationFactor(2); // make the animation twice as slow

ViewPagerCustomDuration.java:

import android.content.Context;
import android.support.v4.view.ViewPager;
import android.util.AttributeSet;
import android.view.animation.Interpolator;

import java.lang.reflect.Field;

public class ViewPagerCustomDuration extends ViewPager {

    public ViewPagerCustomDuration(Context context) {
        super(context);
        postInitViewPager();
    }

    public ViewPagerCustomDuration(Context context, AttributeSet attrs) {
        super(context, attrs);
        postInitViewPager();
    }

    private ScrollerCustomDuration mScroller = null;

    /**
     * Override the Scroller instance with our own class so we can change the
     * duration
     */
    private void postInitViewPager() {
        try {
            Class<?> viewpager = ViewPager.class;
            Field scroller = viewpager.getDeclaredField("mScroller");
            scroller.setAccessible(true);
            Field interpolator = viewpager.getDeclaredField("sInterpolator");
            interpolator.setAccessible(true);

            mScroller = new ScrollerCustomDuration(getContext(),
                    (Interpolator) interpolator.get(null));
            scroller.set(this, mScroller);
        } catch (Exception e) {
        }
    }

    /**
     * Set the factor by which the duration will change
     */
    public void setScrollDurationFactor(double scrollFactor) {
        mScroller.setScrollDurationFactor(scrollFactor);
    }

}

ScrollerCustomDuration.java:

import android.annotation.SuppressLint;
import android.content.Context;
import android.view.animation.Interpolator;
import android.widget.Scroller;

public class ScrollerCustomDuration extends Scroller {

    private double mScrollFactor = 1;

    public ScrollerCustomDuration(Context context) {
        super(context);
    }

    public ScrollerCustomDuration(Context context, Interpolator interpolator) {
        super(context, interpolator);
    }

    @SuppressLint("NewApi")
    public ScrollerCustomDuration(Context context, Interpolator interpolator, boolean flywheel) {
        super(context, interpolator, flywheel);
    }

    /**
     * Set the factor by which the duration will change
     */
    public void setScrollDurationFactor(double scrollFactor) {
        mScrollFactor = scrollFactor;
    }

    @Override
    public void startScroll(int startX, int startY, int dx, int dy, int duration) {
        super.startScroll(startX, startY, dx, dy, (int) (duration * mScrollFactor));
    }

}

आशा है कि यह किसी की मदद करता है!

Comments

मुझे यह समाधान स्वीकार किए गए उत्तर से बेहतर लगता है क्योंकि कस्टम व्यू पेजर एक ड्रॉप-इन क्लास है जो मौजूदा कोड में न्यूनतम परिवर्तन है। कस्टम ViewPager के स्थिर आंतरिक वर्ग के रूप में कस्टम घुमक्कड़ होने से यह और भी अधिक संक्षिप्त हो जाता है।

— इमानुएल मोकेलिन

आप ProGuard उपयोग कर रहे हैं इस लाइन को जोड़ने के लिए भूल नहीं है, तो: रखें वर्ग android.support.v4 ** {*;} अन्यथा आप नल पॉइंटर मिलेगा जब getDeclaredField ()।

— GuilhE

मेरा सुझाव है कि एक टर्नरी को अपडेट करना, क्योंकि आप किसी को भी 0 कारक में पारित करने की अनुमति नहीं देना चाहते हैं, इससे आपकी समय अवधि टूट जाएगी। अंतिम पैरामीटर को अपडेट करें जो आप mScrollFactor> 0 में पास कर रहे हैं? (int) (अवधि * mScrollFactor): अवधि

— portfoliobuilder

मैं यह भी सुझाव देता हूं कि आप अपने वर्ग में स्क्रॉल फैक्टर की स्थापना करते समय एक शून्य जांच करें, ViewPagerCustomDuration। आप mScroller के साथ एक अशक्त वस्तु के रूप में त्वरित करते हैं, आपको पुष्टि करनी चाहिए कि उस वस्तु पर स्क्रॉल कारक को सेट करने का प्रयास करते समय यह अभी भी अशक्त नहीं है।

— portfoliobuilder

@portfoliobuilder मान्य टिप्पणियां, हालांकि ऐसा लगता है कि आप एक अधिक रक्षात्मक प्रोग्रामिंग शैली के पक्ष में हैं जो IMO SO पर स्निपेट की तुलना में अपारदर्शी पुस्तकालयों के लिए अधिक अनुकूल है। स्क्रॉल फ़ैक्टर को <= 0 पर सेट करने के साथ-साथ एक बिना-इंस्टेंट दृश्य पर सेटस्क्रोलड्यूरेशनफैक्टर को कॉल किए कुछ ऐसा है जो अधिकांश एंड्रॉइड देव को रनटाइम चेक के बिना करने में सक्षम होना चाहिए।

— ओलेग वासकेविच

Answer 3

मुझे @ df778899 के उत्तर और Android ValueAnimator API के आधार पर, बेहतर समाधान मिला है । यह प्रतिबिंब के बिना ठीक काम करता है और बहुत लचीला है। इसके अलावा कस्टम ViewPager बनाने और android.support.v4.view पैकेज में डालने की कोई आवश्यकता नहीं है। यहाँ एक उदाहरण है:

private void animatePagerTransition(final boolean forward) {

    ValueAnimator animator = ValueAnimator.ofInt(0, viewPager.getWidth() - ( forward ? viewPager.getPaddingLeft() : viewPager.getPaddingRight() ));
    animator.addListener(new Animator.AnimatorListener() {
        @Override
        public void onAnimationStart(Animator animation) {
        }

        @Override
        public void onAnimationEnd(Animator animation) {
            viewPager.endFakeDrag();
        }

        @Override
        public void onAnimationCancel(Animator animation) {
            viewPager.endFakeDrag();
        }

        @Override
        public void onAnimationRepeat(Animator animation) {
        }
    });

    animator.setInterpolator(new AccelerateInterpolator());
    animator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {

        private int oldDragPosition = 0;

        @Override
        public void onAnimationUpdate(ValueAnimator animation) {
            int dragPosition = (Integer) animation.getAnimatedValue();
            int dragOffset = dragPosition - oldDragPosition;
            oldDragPosition = dragPosition;
            viewPager.fakeDragBy(dragOffset * (forward ? -1 : 1));
        }
    });

    animator.setDuration(AppConstants.PAGER_TRANSITION_DURATION_MS);
    viewPager.beginFakeDrag();
    animator.start();
}

Comments

मुझे लगता है कि यह कमतर है। यह उपयोग करता है startFakeDragऔर endFakeDragजो अधिक से अधिक करने के लिए होता है ViewPagerवह बॉक्स से बाहर उपलब्ध है । यह मेरे लिए बहुत अच्छा काम करता है और ठीक वैसा ही है जैसा मैं देख रहा था

— user3280133

यह एक महान समाधान है, धन्यवाद। एक छोटी सी वृद्धि, हालांकि: यह पैडिंग के साथ एक व्यूपेजर के लिए काम करने के लिए, पहली पंक्ति होनी चाहिए ... ValueAnimator.ofInt (0, viewPager.getWidth) () - (आगे? ViewPager .getPaddingLeft (): viewPager.getPaddingRight ()? ));

— दिमित्री

यह अब तक का सबसे सरल / समग्र / उत्तरदायी समाधान था क्योंकि यह प्रतिबिंब की अवहेलना करता है और उपरोक्त समाधानों की तरह सीलिंग उल्लंघन से बचता है

— रायन

@lobzic, वास्तव में आप अपने animatePagerTransition(final boolean forwardतरीके को कहाँ कहते हैं ? यही मैं उलझन में हूं। क्या आप इसे ViewPager.OnPageChangeListenerइंटरफ़ेस विधियों में से एक में कहते हैं ? या कहीं और?

— साकिबॉय

कोई बदसूरत प्रतिबिंब हैक नहीं। आसानी से विन्यास करने योग्य। बहुत अच्छा जवाब।

— ओरेन

Answer 4

जैसा कि आप ViewPager स्रोतों में देख सकते हैं , mScroller ऑब्जेक्ट द्वारा नियंत्रित फ्लिंग की अवधि। में documantation हम पढ़ सकते हैं:

स्क्रॉल की अवधि को कंस्ट्रक्टर में पारित किया जा सकता है और अधिकतम समय निर्दिष्ट करता है जो स्क्रॉल एनीमेशन को लेना चाहिए

इसलिए, यदि आप गति को नियंत्रित करना चाहते हैं, तो आप प्रतिबिंब के माध्यम से mScroller ऑब्जेक्ट बदल सकते हैं।

आपको कुछ इस तरह लिखना चाहिए:

setContentView(R.layout.main);
mPager = (ViewPager)findViewById(R.id.view_pager);
Field mScroller = ViewPager.class.getDeclaredField("mScroller");   
mScroller.setAccessible(true);
mScroller.set(mPager, scroller); // initialize scroller object by yourself 

Comments

मैं यह करने में थोड़ा उलझन में हूँ - मैं XML फ़ाइल में ViewPager सेट कर रहा हूं और मैंने इसे एक mPager को सौंपा है, और setAdapter (mAdapter) ... क्या मुझे एक वर्ग बनाना चाहिए जो ViewPager का विस्तार करता है?

— एलेक्स केली

आपको कुछ इस तरह लिखना चाहिए: setContentView (R.layout.main); mPager = (ViewPager) findViewById (R.id.view_pager); फ़ील्ड mScroller = ViewPager.class.getDeclaredField ("mScroller"); mScroller.setAccessible (सही); mScroller.set (mPager, scroller); // अपने आप से

— स्कोरर

मैंने अभी एक और उत्तर पोस्ट किया है ... यह काम नहीं कर रहा है ... क्या आपके पास मुझे निर्देश देने के लिए कुछ समय होगा क्यों नहीं?

— एलेक्स केली

स्रोतों पर अधिक ध्यान देने के बाद: mScroller.startScroll (sx, sy, dx, dy) ढूंढें; ViewPager स्रोत में और Scroller अहसास को देखो। startScroll, DEFAULT_DURATION पैरामैटर के साथ अन्य आरंभक कॉल करता है। स्थिर अंतिम क्षेत्र के लिए एक और मूल्य बनाना असंभव है, इसलिए एक अवसर छोड़ दिया - ViewPager के सुगम को

— पार करना

Answer 5

यह सही समाधान नहीं है, आप वेग को धीमा नहीं कर सकते क्योंकि यह एक है int। लेकिन मेरे लिए यह काफी धीमा है और मुझे प्रतिबिंब का उपयोग करने की आवश्यकता नहीं है।

जहां कक्षा है, वहां पैकेज देखें। smoothScrollToपैकेज दृश्यता है।

package android.support.v4.view;

import android.content.Context;
import android.util.AttributeSet;

public class SmoothViewPager extends ViewPager {
    private int mVelocity = 1;

    public SmoothViewPager(Context context) {
        super(context);
    }

    public SmoothViewPager(Context context, AttributeSet attrs) {
        super(context, attrs);
    }

    @Override
    void smoothScrollTo(int x, int y, int velocity) {
        //ignore passed velocity, use one defined here
        super.smoothScrollTo(x, y, mVelocity);
    }
}

Comments

ध्यान दें कि पहली पंक्ति: "android.support.v4.view पैकेज;" अनिवार्य है और आपको अपने src रूट पर ऐसा पैकेज बनाना चाहिए। यदि आप ऐसा नहीं करेंगे तो आपका कोड संकलित नहीं होगा।

— एलहान मिश्राकी

@ ईशानमिश्रकी वास्तव में, मेरा यही मतलब है Notice the package where the class is।

— पावलज़ीबा

रुको, रुको, रुको, रुको ... वुउउत? आप sdk package-local fields/ का उपयोग कर सकते हैं methods, यदि आप एंड्रॉइड स्टूडियो को लगता है कि आप एक ही पैकेज का उपयोग कर रहे हैं? क्या मैं वही हूँ जो कुछ सूंघ रहा हूँ sealing violation?

— बार्टेक लिपिंस्की 11

यह वास्तव में एक अच्छा समाधान है, लेकिन यह मेरे लिए काम नहीं कर रहा था क्योंकि व्यूपोलर स्कॉलर द्वारा इस्तेमाल किए गए इंटरपोलर इस मामले में अच्छा व्यवहार नहीं करते हैं। इसलिए मैंने mScroller प्राप्त करने के लिए प्रतिबिंब का उपयोग करते हुए दूसरों के साथ आपका समाधान जोड़ा। इस तरह, मैं मूल स्कॉलर का उपयोग कर सकता हूं, जब उपयोगकर्ता पेजेट करता है, और मेरा कस्टम स्क्रोलर तब होता है जब मैं प्रोग्राम को सेटक्रिट इटेम () के साथ प्रोग्राम बदल देता हूं।

— रोलगंन

Answer 6

ViewPager पर फर्जी तरीके से वैकल्पिक समाधान प्रदान करने के लिए लगता है।

उदाहरण के लिए यह आइटम 0 से 1 तक का पेज होगा:

rootView.setOnClickListener(new OnClickListener() {
  @Override
  public void onClick(View v) {
      ViewPager pager = (ViewPager) getActivity().findViewById(R.id.pager);
      //pager.setCurrentItem(1, true);
      pager.beginFakeDrag();
      Handler handler = new Handler();
      handler.post(new PageTurner(handler, pager));
  }
});


private static class PageTurner implements Runnable {
  private final Handler handler;
  private final ViewPager pager;
  private int count = 0;

  private PageTurner(Handler handler, ViewPager pager) {
    this.handler = handler;
    this.pager = pager;
  }

  @Override
  public void run() {
    if (pager.isFakeDragging()) {
      if (count < 20) {
        count++;
        pager.fakeDragBy(-count * count);
        handler.postDelayed(this, 20);
      } else {
        pager.endFakeDrag();
      }
    }
  }
}

( count * countबस इतना ही है कि ड्रैग स्‍पीड बढ़ाई जाए क्योंकि यह आगे बढ़ जाती है)

Answer 7

मैंने उपयोग कर लिया है

DecelerateInterpolator ()

यहाँ उदाहरण है:

  mViewPager = (ViewPager) findViewById(R.id.container);
            mViewPager.setAdapter(mSectionsPagerAdapter);
            Field mScroller = null;
            try {
                mScroller = ViewPager.class.getDeclaredField("mScroller");
                mScroller.setAccessible(true);
                Scroller scroller = new Scroller(this, new DecelerateInterpolator());
                mScroller.set(mViewPager, scroller);
            } catch (NoSuchFieldException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }

Answer 8

स्वीकृत समाधान के आधार पर मैंने पेजर के लिए विस्तार के साथ कोटलिन वर्ग बनाया है। का आनंद लें! :)

class ViewPageScroller : Scroller {

    var fixedDuration = 1500 //time to scroll in milliseconds

    constructor(context: Context) : super(context)

    constructor(context: Context, interpolator: Interpolator) : super(context, interpolator)

    constructor(context: Context, interpolator: Interpolator, flywheel: Boolean) : super(context, interpolator, flywheel)


    override fun startScroll(startX: Int, startY: Int, dx: Int, dy: Int, duration: Int) {
        // Ignore received duration, use fixed one instead
        super.startScroll(startX, startY, dx, dy, fixedDuration)
    }

    override fun startScroll(startX: Int, startY: Int, dx: Int, dy: Int) {
        // Ignore received duration, use fixed one instead
        super.startScroll(startX, startY, dx, dy, fixedDuration)
    }
}

fun ViewPager.setViewPageScroller(viewPageScroller: ViewPageScroller) {
    try {
        val mScroller: Field = ViewPager::class.java.getDeclaredField("mScroller")
        mScroller.isAccessible = true
        mScroller.set(this, viewPageScroller)
    } catch (e: NoSuchFieldException) {
    } catch (e: IllegalArgumentException) {
    } catch (e: IllegalAccessException) {
    }

}

Answer 9

यहां एक पूरी तरह से अलग दृष्टिकोण का उपयोग करके उत्तर दिया गया है। कोई कह सकता है कि यह एक हैके महसूस होता है; हालाँकि, यह प्रतिबिंब का उपयोग नहीं करता है, और मैं तर्क दूंगा कि यह हमेशा काम करेगा।

हम निम्नलिखित कोड अंदर ढूंढते हैं ViewPager.smoothScrollTo:

    if (velocity > 0) {
        duration = 4 * Math.round(1000 * Math.abs(distance / velocity));
    } else {
        final float pageWidth = width * mAdapter.getPageWidth(mCurItem);
        final float pageDelta = (float) Math.abs(dx) / (pageWidth + mPageMargin);
        duration = (int) ((pageDelta + 1) * 100);
    }
    duration = Math.min(duration, MAX_SETTLE_DURATION);

यह कुछ चीजों के आधार पर अवधि की गणना करता है। कुछ भी देखें हम नियंत्रित कर सकते हैं? mAdapter.getPageWidth। आइए हमारे एडेप्टर में ViewPager.OnPageChangeListener को लागू करें । जब ViewPager स्क्रॉल कर रहा हो, तो हम पता लगाने जा रहे हैं और चौड़ाई के लिए नकली मान दें । यदि मैं चाहता हूं कि अवधि हो k*100, तो मैं वापस 1.0/(k-1)आऊंगा getPageWidth। एडॉप्टर के इस भाग में कोटलिन निम्नलिखित है जो अवधि को 400 में बदल देता है:

    var scrolling = false
    override fun getPageWidth(position: Int): Float {
        return if (scrolling) 0.333f else 1f
    }

    // OnPageChangeListener to detect scroll state
    override fun onPageScrollStateChanged(state: Int) {
        scrolling = state == ViewPager.SCROLL_STATE_SETTLING
    }

    override fun onPageScrolled(position: Int, positionOffset: Float, positionOffsetPixels: Int) {
    }

    override fun onPageSelected(position: Int) {
    }

एडॉप्टर को OnPageChangedListener के रूप में जोड़ना न भूलें।

मेरा विशेष मामला सुरक्षित रूप से मान सकता है कि उपयोगकर्ता पृष्ठों के बीच खींचने के लिए स्वाइप नहीं कर सकता है। यदि आपको खींचने के बाद बसने का समर्थन करना है, तो आपको अपनी गणना में थोड़ा और करने की आवश्यकता है।

एक नकारात्मक पक्ष यह है कि यह 100ViewPager में उस हार्डकोड आधार अवधि मान पर निर्भर करता है । अगर वह बदल जाता है, तो इस दृष्टिकोण के साथ आपकी अवधि बदल जाती है।

Answer 10

                binding.vpTour.beginFakeDrag();
                lastFakeDrag = 0;
                ValueAnimator va = ValueAnimator.ofInt(0, binding.vpTour.getWidth());
                va.setDuration(1000);
                va.addUpdateListener(animation -> {
                    if (binding.vpTour.isFakeDragging()) {
                        int animProgress = (Integer) animation.getAnimatedValue();
                        binding.vpTour.fakeDragBy(lastFakeDrag - animProgress);
                        lastFakeDrag = animProgress;
                    }
                });
                va.addListener(new AnimatorListenerAdapter() {
                    @Override
                    public void onAnimationEnd(Animator animation) {
                        super.onAnimationEnd(animation);
                        if (binding.vpTour.isFakeDragging()) {
                            binding.vpTour.endFakeDrag();
                        }
                    }
                });
                va.start();

मैं आप सभी के लिए एक ही मुद्दे को हल करना चाहता था और यह एक ही समस्या के लिए मेरा समाधान है, लेकिन मुझे लगता है कि इस तरह से समाधान अधिक लचीला है क्योंकि आप अपनी पसंद के अनुसार अवधि को बदल सकते हैं और मूल्यों के प्रक्षेप को भी बदल सकते हैं। विभिन्न दृश्य प्रभावों को प्राप्त करने के लिए। मेरा समाधान पृष्ठ "1" से पृष्ठ "2" तक स्वाइप होता है, इसलिए केवल बढ़ती हुई स्थितियों में, लेकिन "lastFakeDrag - animProgress" के बजाय "एनिमप्रोग्रेड - लास्टफ़ेकड्रैग" करके घटते हुए पदों में जाने के लिए आसानी से बदला जा सकता है। मुझे लगता है कि इस कार्य को करने के लिए यह सबसे लचीला समाधान है।