Come sapere viewpager è scorrere verso sinistra o destra?

Question

Sto usando ViewPager (libreria di supporto). Voglio sapere ogni volta che il ViewPager cambia la pagina visibile, sta scorrendo a sinistra oa destra.

Per favore, dammi una soluzione. Qualsiasi consiglio è gradito anche.

Grazie

Answer 1

impostare setOnPageChangeListener al ViewPager

e in

@Override 
public void onPageSelected(int arg0) { 
    if(lastPage>arg0) 
     {//User Move to left} 
    else(lastPage<arg0) 
    {//User Move to right} 
     lastPage=arg0 
} 

Answer 2

Utilizzare l'interfaccia ViewPager.OnPageChangeListener. È possibile utilizzare l'argomento position passato a onPageSelected e confrontarlo con il valore precedente per capire in che modo è stato fatto scorrere lo ViewPager.

Answer 3

è possibile mantenere variabile membro della classe per salvare ultima pagina visitata

private int mLastVisitedPageIndex = 0; 

Quindi utilizzare seguente funzione per controllare la direzione

@Override 
public void onPageSelected(int i) { 
    boolean isMovingForward = mLastVisitedPageIndex < i?true:false; 
    //Use isMovingForward variable anywhere now 
    mLastVisitedPageIndex = i; 
} 

Answer 4

Non è una soluzione perfetta, ma ecco un modo per controllare il senso colpo quando si inizia a strisciare:

new ViewPager.OnPageChangeListener() { 

      private static final float thresholdOffset = 0.5f; 
      private boolean scrollStarted, checkDirection; 

      @Override 
      public void onPageScrolled(int position, float positionOffset, int positionOffsetPixels) { 
       if (checkDirection) { 
        if (thresholdOffset > positionOffset) { 
         Log.i(C.TAG, "going left"); 
        } else { 
         Log.i(C.TAG, "going right"); 
        } 
        checkDirection = false; 
       } 
      } 

      @Override 
      public void onPageSelected(int position) {} 

      @Override 
      public void onPageScrollStateChanged(int state) { 
       if (!scrollStarted && state == ViewPager.SCROLL_STATE_DRAGGING) { 
        scrollStarted = true; 
        checkDirection = true; 
       } else { 
        scrollStarted = false; 
       } 
      } 
     }); 

EDIT: c'è un approccio più elegante che comporta l'uso di un ViewPager.PageTransformer e controllando che sia intervalli di posizione :

... 
myViewPager.setPageTransformer(true, new PageTransformer()); 
... 

public class PageTransformer implements ViewPager.PageTransformer { 
    public void transformPage(View view, float position) { 

     if (position < -1) { 
      // [-00,-1): the page is way off-screen to the left. 
     } else if (position <= 1) { 
      // [-1,1]: the page is "centered" 
     } else { 
      // (1,+00]: the page is way off-screen to the right.   
     } 
    } 
} 

si può imparare di più da: Using ViewPager for Screen Slides

Answer 5

uso che

@Override 
public void onPageSelected(int position) 
{ 
    mCurrentFragmentPosition = position; 
} 
@Override 
public void onPageScrolled(int position, float positionOffset, int positionOffsetPixels) 
{ 
    boolean isGoingToRightPage = position == mCurrentFragmentPosition; 
    if(isGoingToRightPage) 
    { 
     // user is going to the right page 
    } 
    else 
    { 
     // user is going to the left page 
    } 
} 

Answer 6

viewPager.setOnPageChangeListener(new ViewPager.OnPageChangeListener() { 

     private int mCurrentSelectedScreen; 
     private int mNextSelectedScreen; 
     private static final float thresholdOffset = 0.5f; 
     private boolean scrollStarted=true, checkDirection=false; 
     ArrayList<Integer> comp_ary=new ArrayList<Integer>(); 

     @Override 
     public void onPageSelected(int arg0) { 
     } 

     @Override 
     public void onPageScrolled(int position, float positionOffset, 
       int positionOffsetPixels) { 

     //Log.e("positionOffsetPixels : "+positionOffsetPixels, "positionOffset : "+positionOffset); 
     comp_ary.add(positionOffsetPixels); 
      if (checkDirection) { 
        if (comp_ary.get(2) < comp_ary.get(comp_ary.size()-1)) { 

         Log.e("going left", "going left"); 
        } else 
         if (comp_ary.get(2) > comp_ary.get(comp_ary.size()-1)) 
        { 

         Log.e("going right", "going right"); 
        } 
        checkDirection = false; 
        comp_ary=new ArrayList<Integer>(); 
       } 
     } 

     @Override 
     public void onPageScrollStateChanged(int arg0) { 




      if (!scrollStarted && arg0 == ViewPager.SCROLL_STATE_SETTLING) { 
       scrollStarted = true; 
       checkDirection = true; 
      } else { 
       scrollStarted = false; 
      } 


     } 
    }); 

Answer 7

pager.addOnPageChangeListener(new ViewPager.OnPageChangeListener() { 
     @Override 
     public void onPageScrolled(int position, float positionOffset, int positionOffsetPixels) { 

      if(position == pager.getCurrentItem()){ 
       // Move Right 
      } 
      else{ 
       // Move Left 
      } 

     } 

Answer 8

Ho risolto il problema con questa implementazione. Spero che sia d'aiuto.

public static final float EPSILON= 0.001f; 

@Override 
public void onPageScrolled(final int position, final float positionOffset, final int positionOffsetPixels) { 

    // initial position (positionOffset == 0) 
    if (positionOffset < EPSILON) { 
     mIsRight = positionOffset < 0.5; 
     return; 
    } 

    // code here 
    if (mIsRight) { 
    } else { 
    } 
} 

Answer 9

1. Questa è la mia soluzione semplice nel onPageScrolled() metodo ViewPager.OnPageChangeListener:

Answer 10

Stessa soluzione come GuilhE con una correzione minore per evitare di ottenere falsi positivi quando si fa retrocedere a sinistra (scorrendo verso destra) sulla prima pagina (non più p età a sinistra) nel ViewPager. Semplicemente esegue un controllo aggiuntivo per vedere se il colpo si è effettivamente spostato.

new ViewPager.OnPageChangeListener() { 

    private static final float thresholdOffset = 0.5f; 
    private static final int thresholdOffsetPixels = 1; 
    private boolean scrollStarted, checkDirection; 

    @Override 
    public void onPageScrolled(int position, float positionOffset, int positionOffsetPixels) { 
    if (checkDirection) { 
     if (thresholdOffset > positionOffset && positionOffsetPixels > thresholdOffsetPixels) { 
     Log.i(C.TAG, "going left"); 
     } else { 
     Log.i(C.TAG, "going right"); 
     } 
    checkDirection = false; 
    } 
} 

    @Override 
    public void onPageSelected(int position) {} 

    @Override 
    public void onPageScrollStateChanged(int state) { 
    if (!scrollStarted && state == ViewPager.SCROLL_STATE_DRAGGING) { 
     scrollStarted = true; 
     checkDirection = true; 
    } else { 
     scrollStarted = false; 
    } 
    } 
}); 

Answer 11

Possiamo anche fare questo usando un Viewpager personalizzato, che può contenere swipeLeft() e swipeRight() i metodi e il suo metodo onTouchEvent (evento MotionEvent) può contenere ACTION_MOVE e caso ACTION_CANCEL.

// Questo può essere il codice se utile.

public class SwiperViewPager extends ViewPager { 

    SwiperListener mSwiperListener; 
    private float downX; 
    private float downY; 
    private boolean isTouchCaptured; 
    private float upX1; 
    private float upY1; 
    private float upX2; 
    private float upY2; 

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

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

    private float x1, x2; 
    static final int min_distance = 20; 

    boolean eventSent = false; 

    @Override 
    public boolean onTouchEvent(MotionEvent event) { 
     switch (event.getAction()) { 
      case MotionEvent.ACTION_MOVE: { 
       downX = event.getX(); 
       downY = event.getY(); 

       if (!isTouchCaptured) { 
        upX1 = event.getX(); 
        upY1 = event.getY(); 
        isTouchCaptured = true; 
       } else { 
        upX2 = event.getX(); 
        upY2 = event.getY(); 
        float deltaX = upX1 - upX2; 
        float deltaY = upY1 - upY2; 
        //HORIZONTAL SCROLL 
        if (Math.abs(deltaX) > Math.abs(deltaY)) { 
         if (Math.abs(deltaX) > min_distance) { 
          // left or right 
          if (deltaX < 0) { 
           if(!eventSent && mSwiperListener!=null){ 
            mSwiperListener.onLeftSwipe(); 
            eventSent = true; 
           } 
          } 
          if (deltaX > 0) { 
           if(!eventSent && mSwiperListener!=null){ 
            if(mSwiperListener.onRightSwipe()){ 
             eventSent = true; 
             return false; 
            } 
           } 
          } 
         } else { 
          //not long enough swipe... 
         } 
        } 
        //VERTICAL SCROLL 
        else { 
         if (Math.abs(deltaY) > min_distance) { 
          // top or down 
          if (deltaY < 0) { 

          } 
          if (deltaY > 0) { 

          } 
         } else { 
          //not long enough swipe... 
         } 
        } 
       } 
      } 
      break; 
      case MotionEvent.ACTION_UP: 
      case MotionEvent.ACTION_CANCEL:{ 
       isTouchCaptured = false; 
       eventSent = false; 
      } 

     } 
     return super.onTouchEvent(event); 
    } 

    public void setmSwiperListener(SwiperListener mSwiperListener) { 
     this.mSwiperListener = mSwiperListener; 
    } 

    public static interface SwiperListener { 
     public boolean onLeftSwipe(); 

     public boolean onRightSwipe(); 
    } 

} 

Answer 12

private float sumPositionAndPositionOffset; 

@Override 
public void onPageScrolled(int position, float positionOffset, int positionOffsetPixels) { 
    boolean isSwipeToLeft = position + positionOffset > sumPositionAndPositionOffset; 
    sumPositionAndPositionOffset = position + positionOffset; 
}