Czy można wyłączyć przewijanie w ViewPager?

Mam plik, ViewPagerktóry tworzy instancję View. Chciałbym na chwilę wyłączyć przewijanie podglądu i przycisków potomnych, podczas gdy wynik wyszukiwania jest zwracany do widoku. Dzwonię, viewPager.setEnabled(false)ale to go nie wyłącza.

Czy ktoś ma jakieś pomysły?

Prostym rozwiązaniem jest stworzenie własnej podklasy ViewPager, który ma private booleanflagę isPagingEnabled. Następnie zastąp metody onTouchEventi onInterceptTouchEvent. Jeśli isPagingEnabledrówna się true, wywołaj supermetodę, w przeciwnym razie return.

public class CustomViewPager extends ViewPager {

    private boolean isPagingEnabled = true;

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

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

    @Override
    public boolean onTouchEvent(MotionEvent event) {
        return this.isPagingEnabled && super.onTouchEvent(event);
    }

    @Override
    public boolean onInterceptTouchEvent(MotionEvent event) {
        return this.isPagingEnabled && super.onInterceptTouchEvent(event);
    }

    public void setPagingEnabled(boolean b) {
        this.isPagingEnabled = b;
    }
}

Następnie w Layout.XMLpliku zastąp wszystkie <com.android.support.V4.ViewPager>tagi <com.yourpackage.CustomViewPager>tagami.

Ten kod został dostosowany na podstawie tego posta na blogu .

Jest na to łatwe rozwiązanie:

Jeśli chcesz wyłączyć przewijanie podglądu, wtedy:

mViewPager.setOnTouchListener(new OnTouchListener() {

   public boolean onTouch(View arg0, MotionEvent arg1) {
      return true;
   }
}); 

A jeśli chcesz go ponownie włączyć,:

mViewPager.setOnTouchListener(null);

To wystarczy.

Oto mój lekki wariant odpowiedzi Slaytona:

public class DeactivatableViewPager extends ViewPager {
    public DeactivatableViewPager(Context context) {
        super(context);
    }

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

    @Override
    public boolean onTouchEvent(MotionEvent event) {
        return !isEnabled() || super.onTouchEvent(event);
    }

    @Override
    public boolean onInterceptTouchEvent(MotionEvent event) {
        return isEnabled() && super.onInterceptTouchEvent(event);
    }
}

Za pomocą mojego kodu możesz wyłączyć stronicowanie za pomocą setEnable().

Znalazłem proste rozwiązanie.

//disable swiping
mViewPager.beginFakeDrag();

//enable swiping
mViewPager.endFakeDrag();

Proponuję inny sposób rozwiązania tego problemu. Pomysł polega na zawijaniu twojego viewPagera przez scrollView, tak że gdy ten scrollView nie jest przewijalny, twój viewPager też nie jest przewijalny.

Oto mój układ XML:

        <HorizontalScrollView
            android:id="@+id/horizontalScrollView"
            android:layout_width="match_parent"
            android:layout_height="match_parent"
            android:fillViewport="true" >

            <android.support.v4.view.ViewPager
                android:id="@+id/viewPager"
                android:layout_width="wrap_content"
                android:layout_height="match_parent" />

        </HorizontalScrollView>

Nie potrzeba żadnego kodu.

U mnie działa dobrze.

Aby wyłączyć przesuwanie

 mViewPager.beginFakeDrag();

Aby włączyć przesuwanie

 mViewPager.endFakeDrag();

Najlepsze rozwiązanie, które u mnie zadziałało to:

public class DeactivatedViewPager extends ViewPager {

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

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

    @Override
    public boolean canScrollHorizontally(int direction) {
        return false;
    }
}

Po tym przewijanie zostanie wyłączone dotykiem i nadal możesz użyć setCurrentItemmetody zmiany strony.

Oto odpowiedź w Kotlin i AndroidX

import android.content.Context
import android.util.AttributeSet
import android.view.MotionEvent
import androidx.viewpager.widget.ViewPager

class DeactivatedViewPager @JvmOverloads constructor(
    context: Context, attrs: AttributeSet? = null
) : ViewPager(context, attrs) {

    var isPagingEnabled = true

    override fun onTouchEvent(ev: MotionEvent?): Boolean {
        return isPagingEnabled && super.onTouchEvent(ev)
    }

    override fun onInterceptTouchEvent(ev: MotionEvent?): Boolean {
        return isPagingEnabled && super.onInterceptTouchEvent(ev)
    }
}

A co powiesz na to:
użyłem, CustomViewPager
a następnie override scrollTo metody
Sprawdziłem ruch podczas wykonywania wielu małych przesunięć, nie przewija się do innych stron.

public class CustomViewPager extends ViewPager {

    private boolean enabled;

    public CustomViewPager(Context context, AttributeSet attrs) {
        super(context, attrs);
        this.enabled = true;
    }

    @Override
    public boolean onTouchEvent(MotionEvent event) {
        if (this.enabled) {
            return super.onTouchEvent(event);
        }

        return false;
    }

    @Override
    public boolean onInterceptTouchEvent(MotionEvent event) {
        if (this.enabled) {
            return super.onInterceptTouchEvent(event);
        }

        return false;
    }

    public void setPagingEnabled(boolean enabled) {
        this.enabled = enabled;
    } 

    @Override
    public void scrollTo(int x, int y) {
       if(enabled) {
          super.scrollTo(x, y);
       }
    }
}

W moim przypadku używania ViewPager 2 alpha 2 poniższy fragment kodu działa

viewPager.isUserInputEnabled = false

Możliwość wyłączenia wprowadzania danych przez użytkownika (setUserInputEnabled, isUserInputEnabled)

zajrzyj do tego po więcej zmian w viewpager2 1.0.0-alpha02

Wprowadzono również pewne zmiany w najnowszej wersji ViewPager 2 alfa 4

Orientacja i atrybuty isUserScrollable nie są już częścią SavedState

zajrzyj do tego po więcej zmian w viewpager2 # 1.0.0-alpha04

Nowa klasa ViewPager2 z androidx pozwala wyłączyć przewijanie metodą setUserInputEnabled (false)

private val pager: ViewPager2 by bindView(R.id.pager)

override fun onCreate(savedInstanceState: Bundle?) {
    pager.isUserInputEnabled = false
}

Odpowiedź Slaytona działa dobrze. Jeśli chcesz przestać przesuwać jak małpa, możesz zastąpić OnPageChangeListener za pomocą

@Override public void onPageScrollStateChanged(final int state) { 
        switch (state) { 
            case ViewPager.SCROLL_STATE_SETTLING: 
                mPager.setPagingEnabled(false); 
                break; 
            case ViewPager.SCROLL_STATE_IDLE: 
                mPager.setPagingEnabled(true); 
                break; 
        } 
    }

Możesz więc przesuwać tylko obok siebie

import android.content.Context;
import android.support.v4.view.ViewPager;
import android.util.AttributeSet;
import android.view.MotionEvent;
import android.view.animation.DecelerateInterpolator;
import android.widget.Scroller;
import java.lang.reflect.Field;

public class NonSwipeableViewPager extends ViewPager {

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

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

@Override
public boolean onInterceptTouchEvent(MotionEvent event) {
    // stop swipe 
    return false;
}

@Override
public boolean onTouchEvent(MotionEvent event) {
    // stop switching pages
    return false;
}

private void setMyScroller() {
    try {
        Class<?> viewpager = ViewPager.class;
        Field scroller = viewpager.getDeclaredField("mScroller");
        scroller.setAccessible(true);
        scroller.set(this, new MyScroller(getContext()));
    } catch (Exception e) {
        e.printStackTrace();
    }
}

public class MyScroller extends Scroller {
    public MyScroller(Context context) {
        super(context, new DecelerateInterpolator());
    }

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

Następnie w pliku Layout.XML zamień wszystkie tagi --- com.android.support.V4.ViewPager --- na tagi --- com.yourpackage.NonSwipeableViewPager ---.