RecyclerView/नीचे श्रोता

Question

यूपी स्क्रॉल हम कैसे पता चलेगा कि उपयोगकर्ता अप RecyclerView में नीचे स्क्रॉल या?

मैं RecyclerView#OnScrollListener साथ की कोशिश की, यह लंबवत स्क्रॉल और स्क्रॉल राज्य की राशि देता है। स्क्रॉल स्थिति निष्क्रिय होने पर स्थिति को खींचने और स्क्रॉल करने के लिए प्रारंभ करते समय हमें अंतिम स्क्रॉल स्थिति कैसे प्राप्त होती है।

धन्यवाद। अपने पुस्तक श्रोता में

private static int firstVisibleInListview; 

firstVisibleInListview = yourLayoutManager.findFirstVisibleItemPosition(); 

:

Answer 1

इस तरह का प्रयास करें

public void onScrolled(RecyclerView recyclerView, int dx, int dy) 
{ 
    super.onScrolled(recyclerView, dx, dy); 

    int currentFirstVisible = yourLayoutManager.findFirstVisibleItemPosition(); 

    if(currentFirstVisible > firstVisibleInListview) 
     Log.i("RecyclerView scrolled: ", "scroll up!"); 
    else 
     Log.i("RecyclerView scrolled: ", "scroll down!"); 

    firstVisibleInListview = currentFirstVisible; 

} 

Answer 2

स्वीकार किए जाते हैं जवाब ठीक काम करता है, लेकिन @MaciejPigulski नीचे टिप्पणी में और अधिक स्पष्ट और साफ समाधान दे दी है। मैं इसे सिर्फ एक उत्तर के रूप में डाल रहा हूं। मेरा कामकाजी कोड यहाँ है।

mRecyclerView.addOnScrollListener(new RecyclerView.OnScrollListener() { 

    @Override 
    public void onScrolled(RecyclerView recyclerView, int dx, int dy) { 
     super.onScrolled(recyclerView, dx, dy); 
     if (dy > 0) { 
      // Scrolling up 
     } else { 
      // Scrolling down 
     } 
    } 

    @Override 
    public void onScrollStateChanged(RecyclerView recyclerView, int newState) { 
     super.onScrollStateChanged(recyclerView, newState); 

     if (newState == AbsListView.OnScrollListener.SCROLL_STATE_FLING) { 
      // Do something 
     } else if (newState == AbsListView.OnScrollListener.SCROLL_STATE_TOUCH_SCROLL) { 
      // Do something 
     } else { 
      // Do something 
     } 
    } 
}); 

Answer 3

यदि पुनर्नवीनीकरण को स्क्रॉल किया गया है तो मैं एक लेआउट छिपाना चाहता हूं और फिर रीसाइक्लिंगव्यू स्क्रॉल होने पर इसे दृश्यमान बना देता हूं। मैंने कुछ सोच की और इस तर्क के साथ आया। चर y एक वैश्विक स्थिर पूर्णांक है। के रूप में static int y;

y घोषित करने के लिए मत भूलना मुझे आशा है कि यह मदद करता है किसी को :)

mRecyclerView.addOnScrollListener(new EndlessRecyclerOnScrollListener(lLayout) { 
      @Override 
      public void onScrolled(RecyclerView recyclerView, int dx, int dy) { 
      // super.onScrolled(recyclerView, dx, dy); 
       y=dy; 
      } 

      @Override 
      public void onScrollStateChanged(RecyclerView recyclerView, int newState) { 
       super.onScrollStateChanged(recyclerView, newState); 
       if(mRecyclerView.SCROLL_STATE_DRAGGING==newState){ 
        //fragProductLl.setVisibility(View.GONE); 
       } 
       if(mRecyclerView.SCROLL_STATE_IDLE==newState){ 
        // fragProductLl.setVisibility(View.VISIBLE); 
        if(y<=0){ 
         fragProductLl.setVisibility(View.VISIBLE); 
        } 
        else{ 
         y=0; 
         fragProductLl.setVisibility(View.GONE); 
        } 
       } 
      } 
     }); 

Answer 4

एक और सरल उपाय है कि अपने एडाप्टर की मदद से स्क्रॉल दिशा का पता लगाने कर सकते हैं:

class MyRecyclerViewAdapter extends RecyclerView.Adapter<MyViewHolder> { 
    int lastItemPosition = -1; 

    @Override 
    public void onBindViewHolder(MyViewHolder holder, int position) { 
     if (position > lastItemPosition) { 
      // Scrolled Down 
     } 
     else { 
      // Scrolled Up 
     } 
     lastItemPosition = position; 
    } 
} 

^सहायक स्क्रॉलिंग पर आइटम एनिमेशन करते समय।

पीएस: यह आपको आगे बताएगा जब तक किविंडव्यूहोल्डर कॉल पर आगे न हो।

Answer 5

स्क्रॉल श्रोताओं

public class CustomRecyclerView extends RecyclerView 
{ 
private boolean mIsScrolling; 
private boolean mIsTouching; 
private OnScrollListener mOnScrollListener; 
private Runnable mScrollingRunnable; 
private int y = 0; 

public abstract static class OnScrollListener 
{ 
    void onScrollChanged(CustomRecyclerView RvView, int x, int y, int oldX, int oldY) 
    { 
     //if you need just override this method 
    } 

    void onEndScroll(CustomRecyclerView RvView) 
    { 
     //if you need just override this method 
    } 

    protected abstract void onGoUp(); 

    protected abstract void onGoDown(); 
} 

public CustomRecyclerView(final Context context) 
{ 
    super(context); 
} 

public CustomRecyclerView(final Context context, @Nullable final AttributeSet attrs) 
{ 
    super(context, attrs); 
} 

public CustomRecyclerView(final Context context, @Nullable final AttributeSet attrs, final int defStyle) 
{ 
    super(context, attrs, defStyle); 
} 

@Override 
public boolean dispatchTouchEvent(MotionEvent iEv) 
{ 
    if (isEnabled()) 
    { 
     processEvent(iEv); 
     super.dispatchTouchEvent(iEv); 
     return true; //to keep receive event that follow down event 
    } 

    return super.dispatchTouchEvent(iEv); 
} 

private void processEvent(final MotionEvent iEv) 
{ 
    switch (iEv.getAction()) 
    { 
     case MotionEvent.ACTION_DOWN: 
      y = (int) iEv.getY(); 
      break; 

     case MotionEvent.ACTION_UP: 
      y = (int) iEv.getY(); 

      if (mIsTouching && !mIsScrolling && mOnScrollListener != null) 
      { 
       mOnScrollListener.onEndScroll(this); 
      } 

      mIsTouching = false; 
      break; 
     case MotionEvent.ACTION_MOVE: 
      mIsTouching = true; 
      mIsScrolling = true; 

      int newY = (int) iEv.getY(); 
      int difY = y - newY; 

      int MAX_VALUE = 200; 
      int MIN_VALUE = -200; 
      if (difY > MAX_VALUE) 
      { 
       if (mOnScrollListener != null) 
       { 
        mOnScrollListener.onGoDown(); 
       } 
       y = newY; 
      } 
      else if (difY < MIN_VALUE) 
      { 
       if (mOnScrollListener != null) 
       { 
        mOnScrollListener.onGoUp(); 
       } 
       y = newY; 
      } 

      break; 
    } 
} 

@Override 
protected void onScrollChanged(int iX, int iY, int iOldX, int iOldY) 
{ 
    super.onScrollChanged(iX, iY, iOldX, iOldY); 

    if (Math.abs(iOldX - iX) > 0) 
    { 
     if (mScrollingRunnable != null) 
     { 
      removeCallbacks(mScrollingRunnable); 
     } 

     mScrollingRunnable =() -> 
     { 
      if (mIsScrolling && !mIsTouching && mOnScrollListener != null) 
      { 
       mOnScrollListener.onEndScroll(CustomRecyclerView.this); 
      } 

      mIsScrolling = false; 
      mScrollingRunnable = null; 
     }; 

     postDelayed(mScrollingRunnable, 200); 
    } 

    if (mOnScrollListener != null) 
    { 
     mOnScrollListener.onScrollChanged(this, iX, iY, iOldX, iOldY); 
    } 
} 

public void scrollToView(final View iV) 
{ 
    // Get deepChild Offset 
    Point childOffset = new Point(); 
    getDeepChildOffset(CustomRecyclerView.this, iV.getParent(), iV, childOffset); 
    // Scroll to child. 

    CustomRecyclerView.this.scrollToY(childOffset.y); 
} 

private void getDeepChil`enter code here`dOffset(final ViewGroup mainParent, final ViewParent parent, final View child, final Point accumulatedOffset) 
{ 
    ViewGroup parentGroup = (ViewGroup) parent; 
    accumulatedOffset.x += child.getLeft(); 
    accumulatedOffset.y += child.getTop(); 
    if (parentGroup.equals(mainParent)) 
    { 
     return; 
    } 
    getDeepChildOffset(mainParent, parentGroup.getParent(), parentGroup, accumulatedOffset); 
} 

public void scrollToY(final int iY) 
{ 
    CustomRecyclerView.this.postDelayed(() -> 
    { 
     int x = 0; 
     int y = iY; 
     ObjectAnimator xTranslate = ObjectAnimator.ofInt(CustomRecyclerView.this, "scrollX", x); 
     ObjectAnimator yTranslate = ObjectAnimator.ofInt(CustomRecyclerView.this, "scrollY", y); 

     AnimatorSet animators = new AnimatorSet(); 
     animators.setDuration(500L); 
     animators.playTogether(xTranslate, yTranslate); 
     animators.addListener(new Animator.AnimatorListener() 
     { 

      @Override 
      public void onAnimationStart(Animator arg0) 
      { 
       // noting 
      } 

      @Override 
      public void onAnimationRepeat(Animator arg0) 
      { 
       // noting 
      } 

      @Override 
      public void onAnimationEnd(Animator arg0) 
      { 
       // noting 
      } 

      @Override 
      public void onAnimationCancel(Animator arg0) 
      { 
       // noting 
      } 
     }); 
     animators.start(); 
    }, 300); 
} 

public void scrollToTop() 
{ 
    scrollToY(0); 
} 

public void setOnRvScrollListener(OnScrollListener mOnEndScrollListener) 
{ 
    this.mOnScrollListener = mOnEndScrollListener; 
} 
} 

के सभी प्रकार के साथ CustomRecyclerView की मेरी कार्यान्वयन नहीं है और उपयोग

private void setRecyclerViewSettings() 
{ 
    mRv.setLayoutManager(new LinearLayoutManager(getActivity())); 
    mRv.setOnRvScrollListener(mScrollListener); 
} 

private CustomRecyclerView.OnScrollListener mScrollListener = new CustomRecyclerView.OnScrollListener() 
{ 
    @Override 
    protected void onGoUp() 
    { 
     AppUtils.hideKeyboard(getContext(), mRvDynamicFormQuestions.getFocusedChild()); 
    } 

    @Override 
    protected void onGoDown() 
    { 
     AppUtils.hideKeyboard(getContext(), mRvDynamicFormQuestions.getFocusedChild()); 
    } 
}; 

Answer 6

public void ScrollUp(View view) { 
    GridLayoutManager layoutManager = (GridLayoutManager) recyclerView.getLayoutManager(); 

    RecyclerView.SmoothScroller smoothScroller = new LinearSmoothScroller(getBaseContext()){ 
     @Override protected int getVerticalSnapPreference() { 
      return LinearSmoothScroller.SNAP_TO_START; 
     } 
    }; 
    smoothScroller.setTargetPosition(0); 
    layoutManager.startSmoothScroll(smoothScroller); 
}