Contrôler le sens de ViewPager vous pouvez faire défiler, de façon dynamique avec INTERFACE utilisateur commentaires

Je travaille sur une application qui utilise de nombreuses pages à feuilleter, cependant, à certaines pages que je voudrais être en mesure d'empêcher le défilement de la page suivante jusqu'à ce qu'ils ont sélectionné quelque chose.

Au moment où je l'ai étendu ViewPager:

/* (non-Javadoc)
 * @see android.support.v4.view.ViewPager#onInterceptTouchEvent(android.view.MotionEvent)
 */
@Override
public boolean onInterceptTouchEvent(MotionEvent event) {
    if (this.canGoLeft || this.canGoRight) {
        return super.onInterceptTouchEvent(event);
    }

    return false;
}

/* (non-Javadoc)
 * @see android.support.v4.view.ViewPager#onTouchEvent(android.view.MotionEvent)
 */
@Override
public boolean onTouchEvent(MotionEvent ev) {
    boolean lockScroll = false;
    switch (ev.getAction()) {
    case MotionEvent.ACTION_DOWN:
        lastX = ev.getX();
        lockScroll = false;
        return super.onTouchEvent(ev);
    case MotionEvent.ACTION_MOVE:
        if (canGoLeft && lastX < ev.getX()) {
            lockScroll = false;
        } else if (canGoRight && lastX > ev.getX()) {
            lockScroll = false;
        } else {
            lockScroll = true;
        }


        lastX = ev.getX();

        break;
    }

    lastX = ev.getX();

    if (lockScroll) {
        //make callback to prevent movement
        if (mOnPreventCallback != null) {
            mOnPreventCallback.onPreventMovement();
        }
        return false;
    } else {
        return super.onTouchEvent(ev);
    }
}

Note: j'ai essayé de mettre en œuvre empêcher de glisser à la précédente, cependant vous pouvez toujours glisser à la page précédente, mais vous avez besoin de passer de l'extrémité gauche et faites glisser vers la droite un peu. Il est capricieux, mais il n'empêche pas de glisser complètement.

Trois choses que je veux faire ici:

Empêcher le défilement à l'écran suivant jusqu'à ce qu'ils ont sélectionné un article ou quelque chose
Empêcher le défilement à l'écran précédent dans l'ensemble (partiellement mis en œuvre)
Donner de la rétroaction à l'utilisateur de montrer que le défilement est désactivé, comme la façon dont Android montre le haut et le bas des écrans avec un dégradé.

OriginalL'auteur Tim Kist | 2012-11-07

android android-viewpager

Quand j'ai été confronté à un problème similaire, j'ai fait mon propre Écouteur avec un gestureDetector et fait-il pas répondre à balayage à tous, vous pouvez facilement ajuster pour ne pas répondre à glisser vers la droite que sous certaines conditions. Cela devrait répondre à vos numéros 1 et 2.

C'est de l'auditeur:

public class OnSwipeTouchListener implements OnTouchListener {
@SuppressWarnings("deprecation")
private final GestureDetector gestureDetector = new GestureDetector(new GestureListener());
public boolean onTouch(final View v, final MotionEvent event) {
return gestureDetector.onTouchEvent(event);
}
private final class GestureListener extends SimpleOnGestureListener {
private static final int SWIPE_THRESHOLD = 100;
private static final int SWIPE_VELOCITY_THRESHOLD = 100;
@Override
public boolean onDown(MotionEvent e) {
return true;
}
@Override
public boolean onSingleTapConfirmed(MotionEvent e) {
onTouch(e);
return true;
}
@Override
public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) {
boolean result = false;
try {
float diffY = e2.getY() - e1.getY();
float diffX = e2.getX() - e1.getX();
if (Math.abs(diffX) > Math.abs(diffY)) {
if (Math.abs(diffX) > SWIPE_THRESHOLD && Math.abs(velocityX) > SWIPE_VELOCITY_THRESHOLD) {
if (diffX > 0) {
onSwipeRight();
} else {
onSwipeLeft();
}
}
} else {
//onTouch(e);
}
} catch (Exception exception) {
exception.printStackTrace();
}
return result;
}
}
public void onTouch(MotionEvent e) {
}
public void onSwipeRight() {
//call this only if your condition was set
}
public void onSwipeLeft() {
//nothing, this means,swipes to left will be ignored
}
public void onSwipeTop() {
}
public void onSwipeBottom() {
}
}

et c'est un exemple d'utilisation :

viewPager.setOnTouchListener(new OnSwipeTouchListener() {
public void onSwipeRight() {
if(your conditionIsMet){
//move your pager view to the right
}
}
});

Il y a peut être plus simple et plus élégante solution, mais cela a bien fonctionné pour moi.

Il a travaillé grandement..thanks...@slezadav

OriginalL'auteur slezadav

2

J'ai été googler haute et basse pour une bonne façon de résoudre ce problème...
J'ai essayé primordial ontouchevent etc...

J'ai décidé que c'était la meilleure solution pour moi (et moins hacky)..
était juste pour mettre en œuvre un maximum ou minimum tracker et le régler à la page en cours
```
        maxPageToScroll = viewPager.getCurrentItem();
minPageToScroll = viewPager.getCurrentItem();
```
puis ajouter à la onPageSelected" méthode:
```
public void onPageSelected(int position) {
if (position < minPageToScroll) {
viewPager.setCurrentItem(maxPageToScroll);
}
else if (position > maxPageToScroll) {
viewPager.setCurrentItem(maxPageToScroll);
//you can alert here that user needs to do certain actions before proceeding
}
else { 
//enter normal commands here
}
```
par conséquent, lorsque les conditions sont remplies, vous augmentez simplement la maxpage par un..
```
        maxPageToScroll = viewPager.getCurrentItem() + 1;
```
remarque que cela ne va pas empêcher l'utilisateur de défilement... ça empêche vue pager de changer de pages.

Le problème avec cette solution est que l'onglet indicateur (le soulignement sous le titre de l'onglet) se déplace vers la nouvelle page même si la page n'est pas affichée

OriginalL'auteur BtzX
1

Je ne pense pas que l'extension de ViewPager est nécessaire. Ce que vous devez faire est de modifier la liste des pages fournies à la PagerAdapter à la volée. Ce qui signifie que, vous de vérifier si une certaine page est marqué "terminé" et ensuite seulement ajouter de la page suivante pour la liste. C'est comment ViewPager œuvres.

Prendre un coup d'oeil à Roman Nurik de l'assistant-pager mise en œuvre. Dans MainActivity il existe une méthode appelée recalculateCutOffPage qui fait ce que je dit.

C'est ce que je suis à la recherche pour le moment. Merci.
Résout être en mesure d'empêcher le passage des doigts à droite mais pas à gauche. Ma solution a été d'une combinaison de WizardPager et personnalisé ViewPager

OriginalL'auteur Nimrod Dayan

vous pouvez utiliser votre affichage personnalisé pager

public class CustomViewPager extends ViewPager
{   
float mStartDragX;
OnSwipeOutListener mListener;
Context context;
public static boolean enabled;
public CustomViewPager(Context context, AttributeSet attrs)
{
super(context, attrs);
this.context = context;
enabled = true;
}
@Override
public boolean onTouchEvent(MotionEvent event)
{
if (enabled) //view pager scrolling enable if true
{
return super.onTouchEvent(event);
}
return false;
}
@Override
public boolean onInterceptTouchEvent(MotionEvent ev)
{
if (enabled)enter code here
{
return super.onInterceptTouchEvent(ev);
}
else  //view pager disable scrolling 
{
float x = ev.getX();
switch (ev.getAction())
{
case MotionEvent.ACTION_DOWN:
mStartDragX = x;
break;
case MotionEvent.ACTION_MOVE:
if (mStartDragX < x - 100)//100 value velocity
{
//Left scroll 
//return super.onInterceptTouchEvent(ev); 
}
else
if (mStartDragX > x + 100)
{
//Right scroll 
//return super.onInterceptTouchEvent(ev);
}
break;
}
}
return false;
}
public void setOnSwipeOutListener(OnSwipeOutListener listener)
{
mListener = listener;
}
public interface OnSwipeOutListener
{
public void onSwipeOutAtStart();
public void onSwipeOutAtEnd();
}

}

en xml côté... <<yourpackageName>.CustomViewPager> android:id="@+id/pager" android:layout_width="match_parent" android:layout_height="match_parent" />

OriginalL'auteur Dedaniya HirenKumar

-1

J'ai mises en œuvre viewpager pour un assistant avec un max la page que l'utilisateur ne peut pas passer.

À la fin la solution était dans l'adaptateur.
J'ai changé le comte de la PagerAdapter et de cette façon, les blocs à l'utilisateur de passer le max de page:
```
@Override
public int getCount() {
return mProgress; //max page + 1
}
```
Lorsque l'utilisateur passe à la page suivante:
```
private void setWizardProgress(int progress) {
if(progress > mProgress) {
mProgress = progress;
mWizardPagerAdapter.notifyDataSetChanged();
}
}
```
De cette façon, lorsque l'utilisateur est au max la page, il ne peut pas faire défiler vers la droite jusqu'à ce que le progrès est mis à jour.

C'est OK pour empêcher le passage des doigts à droite, mais que dire de gauche?
Si vous souhaitez désactiver le balayage complètement regardez ici http://stackoverflow.com/questions/9650265/how-do-disable-paging-by-swiping-with-finger-in-viewpager-but-still-be-able-to-s

OriginalL'auteur Aviv Mor

Vous devez vous connecter pour publier un commentaire.