ViewPager 作为循环队列/包装

Question

我使用 ViewPager 和 FragmentStatePagerAdapter 来允许在某些片段之间导航。

假设我有三个片段：A、B 和 C。 ViewPager 最初显示片段 A，并允许您通过从右向左滑动来导航到片段 B，然后通过再次滑动来导航到片段 C。这允许以下导航路径：A <--> B<--> C。

我想要的是能够在片段 A 上从左向右滑动并让 ViewPager 显示片段 C，即让它表现为循环队列并允许 ... --> C<--> A<--> B<--> C<--> A <-- ...

我不希望片段在其他位置重复（即最终出现超过三个实例）。

ViewPager 可以实现这种包装功能吗？

Answer 1

我已经实现了一个 ViewPager/PagerAdapter ，它可以允许伪无限分页行为。它的工作原理是指定一个非常大的数字作为实际计数，但将它们映射到数据集/页面集的实际范围。它还将开头偏移了很大的数字，以便您可以立即从“第一”页滚动到左侧。

一旦你到达第 1,000,000 页，它就不再那么有效了（滚动时你会看到图形故障），但这通常不是现实世界的用例。我可以通过偶尔将计数重置为较低的数字来解决此问题，但我暂时保留它的原样。

InfinitePagerAdapter 包装了现有的 ViewPager，因此使用非常透明。 InfiniteViewPager 确实做了一些工作来确保您可以向左和向右滚动多次。

https://github.com/antonyt/InfiniteViewPager

Answer 2

这是一个没有假页面的解决方案，并且工作起来就像一个魅力：

public class CircularViewPagerHandler implements ViewPager.OnPageChangeListener {
    private ViewPager   mViewPager;
    private int         mCurrentPosition;
    private int         mScrollState;

    public CircularViewPagerHandler(final ViewPager viewPager) {
        mViewPager = viewPager;
    }

    @Override
    public void onPageSelected(final int position) {
        mCurrentPosition = position;
    }

    @Override
    public void onPageScrollStateChanged(final int state) {
        handleScrollState(state);
        mScrollState = state;
    }

    private void handleScrollState(final int state) {
        if (state == ViewPager.SCROLL_STATE_IDLE) {
            setNextItemIfNeeded();
        }
    }

    private void setNextItemIfNeeded() {
        if (!isScrollStateSettling()) {
            handleSetNextItem();
        }
    }

    private boolean isScrollStateSettling() {
        return mScrollState == ViewPager.SCROLL_STATE_SETTLING;
    }

    private void handleSetNextItem() {
        final int lastPosition = mViewPager.getAdapter().getCount() - 1;
        if(mCurrentPosition == 0) {
            mViewPager.setCurrentItem(lastPosition, false);
        } else if(mCurrentPosition == lastPosition) {
            mViewPager.setCurrentItem(0, false);
        }
    }

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

您只需将其设置为 ViewPager 作为 onPageChangeListener 即可：（ ** 现在已弃用 ** 检查编辑注释）

viewPager.setOnPageChangeListener(new CircularViewPagerHandler(viewPager));

以避免在 ViewPager 的“末尾”出现蓝色光芒，您应该将此行应用到放置 ViewPager 的 xml 中：

android:overScrollMode="never"

我们改进了上面的解决方案，并在 github。请随意检查一下:)

编辑::根据@Bhavana评论，只需使用addOnPageChangeListener而不是setOnPageChangeListener，因为稍后已弃用。

 viewPager.addOnPageChangeListener(new CircularViewPagerHandler(viewPager));

Answer 3

另一种方法是将视图分页器中第一个元素的假副本添加到适配器的末尾，并将最后一个元素的假副本添加到开头。然后，当您查看视图寻呼机中的第一个/最后一个元素时，无需动画即可更改页面。

所以基本上，视图寻呼机中的第一个/最后一个元素是假的，只是为了生成正确的动画，然后切换到结束/开始。
例子：

list.add(list.get(0)); //add the first item again as the last, to create the wrap effect
list.add(0, list.get(list.size()-2)); //insert a copy of the last item as the new first item, so we can scroll backwards too

viewPager.setAdapter(list);
viewPager.setCurrentItem(1, false); //default to the second element (because the first is now a fake)

viewPager.setOnPageChangeListener(new OnPageChangeListener() {
private void handleScrollState(final int state) {
        if (state == ViewPager.SCROLL_STATE_IDLE) { //this is triggered when the switch to a new page is complete
            final int lastPosition = viewPager.getAdapter().getCount() - 1;
            if (currentPosition == lastPosition) {
                viewPager.setCurrentItem(1, false); //false so we don't animate
            } else if (currentPosition == 0) {
                viewPager.setCurrentItem(lastPosition -1, false);
            }
        }

}

Answer 4

我一直在尝试所有的建议、解决方案、库等，但它们不是纯粹的循环，而且大多数时候不支持仅 3 页。

因此，我使用新的 ViewPager2 实现了一个循环 ViewPager 示例，新的 ViewPager 使用 RecyclerView 和 ViewHolder 来处理视图回收并按预期工作！

TLDR： GITHUB

在此示例中，将使用 < code>ViewPager2 和一个 FragmentPagerAdapter 支持 3 个或更多页面之间的循环导航。

我正在使用库 androidx.viewpager2:viewpager2 的 alpha 版本，但版本 1.0.0-alpha06 是 Google 冻结 API 并移动之前计划的最后一个版本到测试版。

1。将 ViewPager2 库添加到 build.gradle 中的依赖项

dependencies {
    implementation 'androidx.viewpager2:viewpager2:1.0.0-alpha06'
}

2.将 ViewPager2 视图添加到您的项目中：

<androidx.viewpager2.widget.ViewPager2 xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@+id/vwpHome"
    android:layout_width="match_parent"
    android:layout_height="match_parent" />

3.创建FragmentStateAdapter适配器：

getItemCount()需要返回一个巨大的数字。 (2147483647)

getCenterPage() 根据 huuuuge 编号返回中心页面。
该方法用于获取在ViewPager2中设置的初始页面的位置，在这种情况下用户需要滑动〜1073741823次才能到达ViewPager2的末尾。

class CircularPagerAdapter(fragmentManager: FragmentManager, lifecycle: Lifecycle) : FragmentStateAdapter(fragmentManager, lifecycle) {

    override fun getItemCount() = Integer.MAX_VALUE

    /**
     * Create the fragment based on the position
     */
    override fun createFragment(position: Int) = HomePagerScreens.values()[position % HomePagerScreens.values().size].fragment.java.newInstance()

    /**
     * Returns the same id for the same Fragment.
     */
    override fun getItemId(position: Int): Long = (position % HomePagerScreens.values().size).toLong()

    fun getCenterPage(position: Int = 0) = Integer.MAX_VALUE / 2 + position
}

HomeScreens 是一个包含页面信息的 ENUM。

enum class HomePagerScreens(@StringRes val title: Int,
                            val fragment: KClass<out Fragment>) {

    HOME_1(R.string.home_1, FragmentHome::class),
    HOME_2(R.string.home_2, FragmentHome::class),
    HOME_3(R.string.home_3, FragmentHome::class)
}

4.将适配器设置为ViewPager

val circularAdapter = CircularPagerAdapter(supportFragmentManager, lifecycle)
vwpHome.apply {
    adapter = circularAdapter
    setCurrentItem(circularAdapter.getCenterPage(), false)
}

Answer 5

刚刚看到这个问题，找到了解决办法。 解决方案链接

对 onPageScrollStateChanged 函数进行以下更改。假设您有 4 个选项卡。

private int previousState, currentState;

public void onPageScrollStateChanged(int state) {              

            int currentPage = viewPager.getCurrentItem();       //ViewPager Type
            if (currentPage == 3 || currentPage == 0){
                previousState = currentState;
                currentState = state;
                if (previousState == 1 && currentState == 0){

                    viewPager.setCurrentItem(currentPage == 0 ? 3 : 0);

                }

            }

        }

如果 state 变量位于现有选项卡中，则其值为 1。

一旦您尝试在第一个选项卡之前或之后导航，该变量就会变为 0你的最后一个标签。因此，比较之前和当前的状态，如代码所示，就完成了。

请参阅 onPageScrollStateChanged 函数此处。

希望有帮助。

Answer 6

这几乎完成了antonyt想要的，它不会让你从A->;尽管是C。 （未经严格测试，但似乎工作得足够好）

public class MyAdapter extends PagerAdapter {
    private List<Object> mItems;
    private int mFakeCount = 0;

    public MyAdapter(Context context, List<Object> items) {
        mItems = items;
        mFakeCount = mItems.size()+1;
    }

    @Override
    public int getCount() {
        return mFakeCount;
    }

    @Override
    public Object instantiateItem(View collection, int position) {
        // make the size larger, and change the position
        // to trick viewpager into paging forever
        if (position >= mItems.size()-1) {
            int newPosition = position%mItems.size();

            position = newPosition;
            mFakeCount++;
        }

        // do your layout inflating and what not here.
        // position will now refer to a correct index into your mItems list
        // even if the user has paged so many times that the view has wrapped
    }
}

Answer 7

如何实现这一点的简单想法。当您的数组包含页面时，只需将此数组添加到正好位于中间的另一个数组中即可。

例如，您有一个包含 15 个元素的数组。因此，将其放入中间的 400 个元素数组中（200 个位置），

然后只需向左和向右填充数组，以便可以四处移动。

示例图片：

它看起来怎么样？

https://youtu.be/7up36ylTzXk

让代码说话:)

https://gist.github.com/gelldur/051394d10f6f98e2c13d

public class CyclicPagesAdapter extends FragmentStatePagerAdapter {

    public CyclicPagesAdapter(FragmentManager fm) {
        super(fm);
    }

    @Override
    public Fragment getItem(int position) {
        return _fragments.get(position).createInstance();
    }

    @Override
    public int getCount() {
        return _fragments.size();
    }

    public void addFragment(FragmentCreator creator) {
        _fragments.add(creator);
    }

    public interface FragmentCreator {
        Fragment createInstance();
    }

    public void clear() {
        _fragments.clear();
    }

    public void add(FragmentCreator fragmentCreator) {
        _fragments.add(fragmentCreator);
    }

    public void finishAdding() {
        ArrayList<FragmentCreator> arrayList = new ArrayList<>(Arrays.asList(new FragmentCreator[MAX_PAGES]));
        arrayList.addAll(MAX_PAGES / 2, _fragments);

        int mrPointer = _fragments.size() - 1;
        for (int i = MAX_PAGES / 2 - 1; i > -1; --i) {
            arrayList.set(i, _fragments.get(mrPointer));
            --mrPointer;
            if (mrPointer < 0) {
                mrPointer = _fragments.size() - 1;
            }
        }

        mrPointer = 0;
        for (int i = MAX_PAGES / 2 + _fragments.size(); i < arrayList.size(); ++i) {
            arrayList.set(i, _fragments.get(mrPointer));
            ++mrPointer;
            if (mrPointer >= _fragments.size()) {
                mrPointer = 0;
            }
        }
        _fragmentsRaw = _fragments;
        _fragments = arrayList;
    }

    public int getStartIndex() {
        return MAX_PAGES / 2;
    }

    public int getRealPagesCount() {
        return _fragmentsRaw.size();
    }

    public int getRealPagePosition(int index) {
        final FragmentCreator fragmentCreator = _fragments.get(index);
        for (int i = 0; i < _fragmentsRaw.size(); ++i) {
            if (fragmentCreator == _fragmentsRaw.get(i)) {
                return i;
            }
        }
        //Fail...
        return 0;
    }

    private static final int MAX_PAGES = 500;
    public ArrayList<FragmentCreator> _fragments = new ArrayList<>();
    public ArrayList<FragmentCreator> _fragmentsRaw;
}

Answer 8

我有一个我相信会起作用的解决方案。它没有经过测试，但它是：

FragmentPagerAdapter 的包装器作为超类：

public abstract class AFlexibleFragmentPagerAdapter extends
        FragmentPagerAdapter
{
    public AFlexibleFragmentPagerAdapter(FragmentManager fm)
    {
        super(fm);
        // TODO Auto-generated constructor stub
    }

    public abstract int getRealCount();

    public abstract int getStartPosition();

    public abstract int transformPosition(int position);
};

然后标准 FragmentPagerAdapter 实现子类化了这个新的抽象类：

public class SomeFragmentPagerAdapter extends
        AFlexibleFragmentPagerAdapter
{

    private Collection<Fragment> someContainer;

    public SomeFragmentPagerAdapter(FragmentManager fm, Container<Fragment> fs)
    {
        super(fm);
        someContainer = fs;
    }

    @Override
    public int getRealCount() { return someContainer.size(); }

    @Override
    public int getStartPosition() { return 0; }

    @Override
    public int transformPosition(int position) { return position; }
};

以及 Cyclic Pager Adapter 实现。

public class SomeCyclicFragmentPagerAdapter extends
        SomeFragmentPagerAdapter 
{
    private int realCount = 0;
    private int dummyCount = 0;
    private static final int MULTI = 3;

    public SomeFragmentPagerAdapter(FragmentManager fm, ...)
    {
        super(fm);
        realCount = super.getCount();
        dummyCount *= MULTI;
    }

    @Override
    public int getCount() { return dummyCount; }

    @Override
    public int getRealCount() { return realCount; }

    @Override
    public int getStartPosition() { return realCount; }

    @Override
    public int transformPosition(int position)
    {
        if (position < realCount) position += realCount;
        else if (position >= (2 * realCount)) position -= realCount;

        return position;
    }
};

ViewPager初始化

    this.mViewPager.setCurrentItem(this.mPagerAdapter.getStartPosition());

最后是回调实现：

    @Override
    public void onPageSelected(int position)
    {
        this.mTabHost.setCurrentTab(position % mPagerAdapter.getRealCount());
        this.mViewPager.setCurrentItem(this.mPagerAdapter
                .transformPosition(position));
    }

    @Override
    public void onTabChanged(String tabId)
    {
        int pos = this.mTabHost.getCurrentTab();

        this.mViewPager.setCurrentItem(this.mPagerAdapter
                .transformPosition(pos));
    }

Answer 9

1. 为项目计数设置一些较大的值，例如 500000。
2. 从适配器返回该值 * 实际项目数。
3. 在 getItem(int i) 上将 i 调整为 -> i = i % 实际项目数。

4. 在 onCreate(Bundle savingInstanceState) 上设置页面 500000/2 的当前项目

   public class MainActivity 扩展 FragmentActivity {
   
       私有最终静态 int ITEMS_MAX_VALUE = 500000;
       私有 int 实际数量 = 10;
       私有ViewPager mPager = null;
   
       私有类 OptionPageAdapter 扩展 FragmentStatePagerAdapter {
           公共OptionPageAdapter（FragmentManager fm）{
               超级（调频）；
           }
   
           @覆盖
           公共片段 getItem(int i) {
               尝试 {
                   i = i % OptionType.values().length;
                   OptionPage optionPage = new OptionPage(i);
                   选项页.id = i;
                   返回选项页；
               } catch (异常 e) {
                   VayoLog.log(Level.WARNING, "无法为 id 创建 OptionFragment: " + i, e);
               }
               返回空值；
           }
   
           @覆盖
           公共 int getCount() {
               返回ITEMS_MAX_VALUE *实际数量；
           }
       }
   
       公共静态类 OptionPage 扩展 Fragment {
           私有 int id = 0
           @可为空
           @覆盖
           公共视图onCreateView（LayoutInflater inflater，ViewGroup容器，Bundle savingInstanceState）{
               View mainView = inflater.inflate(R.layout.main_page, 容器, false);
               返回主视图；
           }
   
       }
   
       @覆盖
       公共无效onCreate（捆绑保存实例状态）{
           super.onCreate(savedInstanceState);
           setContentView(R.layout.main);
           mPager = (ViewPager) findViewById(R.id.main_pager);
           mPager.setOffscreenPageLimit(3);
           mPager.setAdapter(new OptionPageAdapter(this.getSupportFragmentManager()));
           mPager.setCurrentItem(ITEMS_MAX_VALUE/2,false);
   
       }
   
   }
   

Answer 10

1. 在列表的开头添加最后一个元素的假副本。
2. 在末尾添加第一个元素的假副本。

3. 在初始化代码中的某处选择真正的第一个元素：

    mViewPager.setCurrentItem(1);
   

4. 修改 setOnPageChangeListener:

   <预><代码> @Override
   公共无效onPageSelected（int状态）{
   如果（状态==ITEMS_NUMBER + 1）{
   mViewPager.setCurrentItem(1, false);
   } 否则如果（状态== 0）{
   mViewPager.setCurrentItem(ITEMS_NUMBER, false);
   }
   }

Answer 11

基于这种方法

真正的循环，寻呼机标题栏，真正的无刷新滚动

private static final int ITEM_NUM = 5 ; // 5 for smooth pager title strip
private void addFragment(String title, String className) {
    if (fragments.size() < ITEM_NUM) {
        Bundle b = new Bundle();
        b.putInt("pos", fragments.size());
        fragments.add(Fragment.instantiate(this, className, b));

    }
    titles.add(title);
    itemList.add(className);
}

视图页面适配器：

public static class MyFragmentPageAdapter extends FragmentPagerAdapter {

    private HashMap<Long, Fragment> mItems = new HashMap<Long, Fragment>();

    public MyFragmentPageAdapter(FragmentManager fragmentManager) {
        super(fragmentManager);
    }

    @Override
    public long getItemId(int position) {
        int id = java.lang.System.identityHashCode(fragments.get(position));
        return id;
    }

    @Override
    public Fragment getItem(int position) {
        long id = getItemId(position);
        if (mItems.get(id) != null) {
            return mItems.get(id);
        }
        Fragment f = fragments.get(position);
        return f;
    }

    @Override
    public int getCount() {
        return ITEM_NUM;
    }

    @Override
    public CharSequence getPageTitle(int position) {
        String t = titles.get(getItem(position).getArguments()
                .getInt("pos"));
        return t;
    }

    @Override
    public int getItemPosition(Object object) {
        for (int i = 0; i < ITEM_NUM; i++) {
            Fragment item = (Fragment) fragments.get(i);
            if (item.equals((Fragment) object)) {
                return i;
            }
        }
        return POSITION_NONE;
    }
}

使用：

    itemList = new ArrayList<String>();
    fragments = new ArrayList<Fragment>();
    titles = new ArrayList<String>();

    addFragment("Title1", Fragment1.class.getName());
    ...
    addFragment("TitleN", FragmentN.class.getName());

    mAdapter = new MyFragmentPageAdapter(getSupportFragmentManager());
    mViewPager = (ViewPager) findViewById(R.id...);

    mViewPager.setAdapter(mAdapter);
    mViewPager.setCurrentItem(2);
    currPage = 2;
    visibleFragmentPos = 2;

    mViewPager.setOnPageChangeListener(new OnPageChangeListener() {

        @Override
        public void onPageSelected(int curr) {
            dir = curr - currPage;
            currPage = curr;
        }

        private void shiftRight() {
            fragments.remove(0);
            int pos = visibleFragmentPos + 3;
            if (pos > itemList.size() - 1)
                pos -= itemList.size();
            if (++visibleFragmentPos > itemList.size() - 1)
                visibleFragmentPos = 0;
            insertItem(4, pos);

        }

        private void shiftLeft() {
            fragments.remove(4);
            int pos = visibleFragmentPos - 3;
            if (pos < 0)
                pos += itemList.size();
            if (--visibleFragmentPos < 0)
                visibleFragmentPos = itemList.size() - 1;
            insertItem(0, pos);
        }

        private void insertItem(int datasetPos, int listPos) {
            Bundle b = new Bundle();
            b.putInt("pos", listPos);
            fragments.add(datasetPos,
                    Fragment.instantiate(ctx, itemList.get(listPos), b));
        }

        @Override
        public void onPageScrollStateChanged(int state) {

            if (state == ViewPager.SCROLL_STATE_IDLE) {
                if (dir == 1) {
                    shiftRight();
                } else if (dir == -1) {
                    shiftLeft();

                }
                mAdapter.notifyDataSetChanged();
                currPage = 2;
            }
        }
    });

Answer 12

您可以使用 https://github.com/pozitiffcat/circularview
中的简单视图
其特点之一是：

不要重复第一个和最后一个视图，而是使用位图变体

示例：

public class MainActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        CyclicView cyclicView = (CyclicView) findViewById(R.id.cyclic_view);
        cyclicView.setAdapter(new CyclicAdapter() {
            @Override
            public int getItemsCount() {
                return 10;
            }

            @Override
            public View createView(int position) {
                TextView textView = new TextView(MainActivity.this);
                textView.setText(String.format("TextView #%d", position + 1));
                return textView;
            }

            @Override
            public void removeView(int position, View view) {
                // Do nothing
            }
        });
    }
}

Answer 13

我的答案可能与其他人的答案类似。但是我无法在 ViewPager2 中使用 FragmentStateAdapter 找到解决方案。

public class ScreenSlidePagerAdapter extends FragmentStateAdapter {
    private final Fragment[] fragments = {new Fragment4(), new Fragment1(),
            new Fragment2(), new Fragment3(),
            new Fragment4(), new Fragment1()};

    public ScreenSlidePagerAdapter(FragmentActivity fa) { super(fa); }

    @NonNull
    @Override
    public Fragment createFragment(int position) {
        return fragments[position];
    }

    @Override
    public int getItemCount() { return fragments.length; }
}

其中 Fragment1 是第一个显示的。
在您的 MainActivity （或任何具有 ViewPager 的活动）中：

public class MainActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        setContentView(R.layout.activity_main);

        ViewPager2 viewPager = findViewById(R.id.viewpager);
        ScreenSlidePagerAdapter adapter = new ScreenSlidePagerAdapter(this);
        viewPager.setAdapter(adapter);
        viewPager.setCurrentItem(1, false);

        viewPager.registerOnPageChangeCallback(new ViewPager2.OnPageChangeCallback() {
            @Override
            public void onPageScrolled(int position, float positionOffset, int positionOffsetPixels) {
                super.onPageScrolled(position, positionOffset, positionOffsetPixels);

                if (position == 0) {
                    viewPager.setCurrentItem(5, false);
                }
                else if (position == 5) {
                    viewPager.setCurrentItem(1, false);
                }
            }
        });
    }
}

您显然必须根据您拥有的 Fragment 数量更改位置。

Answer 14

抱歉耽搁了，但我已经看到了答案，但我无法坚持，也必须回答:)。

在您的适配器上，在方法 get count 上，按以下步骤操作：

 @Override
    public int getCount() {
        return myList.size() % Integer.MAX_VALUE; 
  }

这会起作用！