Android ViewPager实现智能无限循环滚动回绕效果

2024-02-06 10:20:02 51

android系统提供的ViewPager标准方式是左右可以自由滑动，但是滑动到最左边的极限位置是第一个page，滑动到最右边的位置是最后一个page，当滑动到最左或者最右时候，就不能再滑动/滚动了，这是Android系统默认的ViewPager实现方式。

但是有些情况下开发者可能希望ViewPager能够智能的无限循环滚动回绕，比如现在总共有编号1,2,3,4,5的5个Page。

（1）当用户手指从右往左滚动到最右边/最后面的页面5时候，如果此时用户继续拖住ViewPager往左边滑动，那么ViewPager将回绕、循环到第一个Page->1，接着就是2,3,4,5；

（2）反过来，如果当用户手指从左往右，滑到最左边的第一个Page：1时候，如果此时继续拖住ViewPager继续从左往右滑动，那么将回绕到5，接着就是4,3,2,1.

我们把这种ViewPager称之谓“无限循环滚动回绕”的ViewPager。

这种类型的ViewPager网上有较多实现方式，现在给出一个流程较广的代码实现。

写一个测试的MainActivity.Java:

packagezhangphil.demo;

importjava.util.Random;

importandroid.app.Activity;
importandroid.graphics.Color;
importandroid.os.Bundle;
importandroid.support.v4.view.PagerAdapter;
importandroid.view.Gravity;
importandroid.view.View;
importandroid.view.ViewGroup;
importandroid.widget.TextView;

publicclassMainActivityextendsActivity{

@Override
protectedvoidonCreate(BundlesavedInstanceState){
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
LoopViewPagerviewpager=(LoopViewPager)findViewById(R.id.viewpager);
viewpager.setAdapter(newSamplePagerAdapter());
}

publicclassSamplePagerAdapterextendsPagerAdapter{
privatefinalRandomrandom=newRandom();
privateintmSize;

publicSamplePagerAdapter(){
mSize=5;
}

publicSamplePagerAdapter(intcount){
mSize=count;
}

@Override
publicintgetCount(){
returnmSize;
}

@Override
publicbooleanisViewFromObject(Viewview,Objectobject){
returnview==object;
}

@Override
publicvoiddestroyItem(ViewGroupview,intposition,Objectobject){
view.removeView((View)object);
}

@Override
publicObjectinstantiateItem(ViewGroupview,intposition){
TextViewtextView=newTextView(view.getContext());

textView.setText(position+1+"");
textView.setBackgroundColor(0xff000000|random.nextInt(0x00ffffff));
textView.setGravity(Gravity.CENTER);
textView.setTextColor(Color.WHITE);
textView.setTextSize(50);
view.addView(textView,ViewGroup.LayoutParams.MATCH_PARENT,ViewGroup.LayoutParams.MATCH_PARENT);

returntextView;
}

//增加item
publicvoidaddItem(){
mSize++;
notifyDataSetChanged();
}

//删除item
publicvoidremoveItem(){
mSize--;
mSize=mSize<0?0:mSize;

notifyDataSetChanged();
}
}
}

MainActivity.java需要的布局文件activity_main.xml：

核心关键代码LoopViewPager.java类和LoopViewPager.java依赖的LoopPagerAdapterWrapper.java！

LoopViewPager.java：

packagezhangphil.demo;

importandroid.content.Context;
importandroid.support.v4.view.PagerAdapter;
importandroid.support.v4.view.ViewPager;
importandroid.util.AttributeSet;
importjava.util.ArrayList;
importjava.util.List;

publicclassLoopViewPagerextendsViewPager{
privatestaticfinalbooleanDEFAULT_BOUNDARY_CASHING=false;
privatestaticfinalbooleanDEFAULT_BOUNDARY_LOOPING=true;

privateLoopPagerAdapterWrappermAdapter;
privatebooleanmBoundaryCaching=DEFAULT_BOUNDARY_CASHING;
privatebooleanmBoundaryLooping=DEFAULT_BOUNDARY_LOOPING;
privateListmOnPageChangeListeners;

/**
*helperfunctionwhichmaybeusedwhenimplementingFragmentPagerAdapter
*
*@return(position-1)%count
*/
publicstaticinttoRealPosition(intposition,intcount){
position=position-1;
if(position<0){
position+=count;
}else{
position=position%count;
}
returnposition;
}

/**
*Ifsettotrue,theboundaryviews(i.e.firstandlast)willneverbe
*destroyedThismayhelptoprevent"blinking"ofsomeviews
*/
publicvoidsetBoundaryCaching(booleanflag){
mBoundaryCaching=flag;
if(mAdapter!=null){
mAdapter.setBoundaryCaching(flag);
}
}

publicvoidsetBoundaryLooping(booleanflag){
mBoundaryLooping=flag;
if(mAdapter!=null){
mAdapter.setBoundaryLooping(flag);
}
}

@Override
publicvoidsetAdapter(PagerAdapteradapter){
mAdapter=newLoopPagerAdapterWrapper(adapter);
mAdapter.setBoundaryCaching(mBoundaryCaching);
mAdapter.setBoundaryLooping(mBoundaryLooping);
super.setAdapter(mAdapter);
setCurrentItem(0,false);
}

@Override
publicPagerAdaptergetAdapter(){
returnmAdapter!=null?mAdapter.getRealAdapter():mAdapter;
}

@Override
publicintgetCurrentItem(){
returnmAdapter!=null?mAdapter.toRealPosition(super.getCurrentItem()):0;
}

publicvoidsetCurrentItem(intitem,booleansmoothScroll){
intrealItem=mAdapter.toInnerPosition(item);
super.setCurrentItem(realItem,smoothScroll);
}

@Override
publicvoidsetCurrentItem(intitem){
if(getCurrentItem()!=item){
setCurrentItem(item,true);
}
}

@Override
publicvoidsetOnPageChangeListener(OnPageChangeListenerlistener){
addOnPageChangeListener(listener);
}

@Override
publicvoidaddOnPageChangeListener(OnPageChangeListenerlistener){
if(mOnPageChangeListeners==null){
mOnPageChangeListeners=newArrayList<>();
}
mOnPageChangeListeners.add(listener);
}

@Override
publicvoidremoveOnPageChangeListener(OnPageChangeListenerlistener){
if(mOnPageChangeListeners!=null){
mOnPageChangeListeners.remove(listener);
}
}

@Override
publicvoidclearOnPageChangeListeners(){
if(mOnPageChangeListeners!=null){
mOnPageChangeListeners.clear();
}
}

publicLoopViewPager(Contextcontext){
super(context);
init(context);
}

publicLoopViewPager(Contextcontext,AttributeSetattrs){
super(context,attrs);
init(context);
}

privatevoidinit(Contextcontext){
if(onPageChangeListener!=null){
super.removeOnPageChangeListener(onPageChangeListener);
}
super.addOnPageChangeListener(onPageChangeListener);
}

privateOnPageChangeListeneronPageChangeListener=newOnPageChangeListener(){
privatefloatmPreviousOffset=-1;
privatefloatmPreviousPosition=-1;

@Override
publicvoidonPageSelected(intposition){

intrealPosition=mAdapter.toRealPosition(position);
if(mPreviousPosition!=realPosition){
mPreviousPosition=realPosition;

if(mOnPageChangeListeners!=null){
for(inti=0;i.5){
listener.onPageScrolled(0,0,0);
}else{
listener.onPageScrolled(realPosition,0,0);
}
}
}
}
}
}

@Override
publicvoidonPageScrollStateChanged(intstate){
if(mAdapter!=null){
intposition=LoopViewPager.super.getCurrentItem();
intrealPosition=mAdapter.toRealPosition(position);
if(state==ViewPager.SCROLL_STATE_IDLE&&(position==0||position==mAdapter.getCount()-1)){
setCurrentItem(realPosition,false);
}
}

if(mOnPageChangeListeners!=null){
for(inti=0;i
LoopPagerAdapterWrapper.java：
packagezhangphil.demo;

importandroid.os.Parcelable;
importandroid.support.v4.app.FragmentPagerAdapter;
importandroid.support.v4.app.FragmentStatePagerAdapter;
importandroid.support.v4.view.PagerAdapter;
importandroid.util.SparseArray;
importandroid.view.View;
importandroid.view.ViewGroup;

publicclassLoopPagerAdapterWrapperextendsPagerAdapter{

privatePagerAdaptermAdapter;

privateSparseArraymToDestroy=newSparseArray<>();

privatestaticfinalbooleanDEFAULT_BOUNDARY_CASHING=true;
privatestaticfinalbooleanDEFAULT_BOUNDARY_LOOPING=true;

privatebooleanmBoundaryCaching=DEFAULT_BOUNDARY_CASHING;
privatebooleanmBoundaryLooping=DEFAULT_BOUNDARY_LOOPING;

voidsetBoundaryCaching(booleanflag){
mBoundaryCaching=flag;
}

voidsetBoundaryLooping(booleanflag){
mBoundaryLooping=flag;
}

LoopPagerAdapterWrapper(PagerAdapteradapter){
this.mAdapter=adapter;
}

@Override
publicvoidnotifyDataSetChanged(){
mToDestroy=newSparseArray<>();
super.notifyDataSetChanged();
}

inttoRealPosition(intposition){
intrealPosition=position;
intrealCount=getRealCount();
if(realCount==0)
return0;
if(mBoundaryLooping){
realPosition=(position-1)%realCount;
if(realPosition<0)
realPosition+=realCount;
}

returnrealPosition;
}

publicinttoInnerPosition(intrealPosition){
intposition=(realPosition+1);
returnmBoundaryLooping?position:realPosition;
}

privateintgetRealFirstPosition(){
returnmBoundaryLooping?1:0;
}

privateintgetRealLastPosition(){
returngetRealFirstPosition()+getRealCount()-1;
}

@Override
publicintgetCount(){
intcount=getRealCount();
returnmBoundaryLooping?count+2:count;
}

publicintgetRealCount(){
returnmAdapter.getCount();
}

publicPagerAdaptergetRealAdapter(){
returnmAdapter;
}

@Override
publicObjectinstantiateItem(ViewGroupcontainer,intposition){
intrealPosition=(mAdapterinstanceofFragmentPagerAdapter||mAdapterinstanceofFragmentStatePagerAdapter)
?position:toRealPosition(position);

if(mBoundaryCaching){
ToDestroytoDestroy=mToDestroy.get(position);
if(toDestroy!=null){
mToDestroy.remove(position);
returntoDestroy.object;
}
}
returnmAdapter.instantiateItem(container,realPosition);
}

@Override
publicvoiddestroyItem(ViewGroupcontainer,intposition,Objectobject){
intrealFirst=getRealFirstPosition();
intrealLast=getRealLastPosition();
intrealPosition=(mAdapterinstanceofFragmentPagerAdapter||mAdapterinstanceofFragmentStatePagerAdapter)
?position:toRealPosition(position);

if(mBoundaryCaching&&(position==realFirst||position==realLast)){
mToDestroy.put(position,newToDestroy(container,realPosition,object));
}else{
mAdapter.destroyItem(container,realPosition,object);
}
}

/*
*Delegaterestofmethodsdirectlytotheinneradapter.
*/

@Override
publicvoidfinishUpdate(ViewGroupcontainer){
mAdapter.finishUpdate(container);
}

@Override
publicbooleanisViewFromObject(Viewview,Objectobject){
returnmAdapter.isViewFromObject(view,object);
}

@Override
publicvoidrestoreState(Parcelablebundle,ClassLoaderclassLoader){
mAdapter.restoreState(bundle,classLoader);
}

@Override
publicParcelablesaveState(){
returnmAdapter.saveState();
}

@Override
publicvoidstartUpdate(ViewGroupcontainer){
mAdapter.startUpdate(container);
}

@Override
publicvoidsetPrimaryItem(ViewGroupcontainer,intposition,Objectobject){
mAdapter.setPrimaryItem(container,position,object);
}

/*
*Enddelegation
*/

/**
*Containerclassforcachingtheboundaryviews
*/
staticclassToDestroy{
ViewGroupcontainer;
intposition;
Objectobject;

publicToDestroy(ViewGroupcontainer,intposition,Objectobject){
this.container=container;
this.position=position;
this.object=object;
}
}
}

如果读者有兴趣使用，直接将上面两个核心关键代码放入到自己的项目代码包中，当作自己写的类直接使用即可，写布局时候不要再写ViewPager，而是直接像我上面写的那个布局文件一样用LoopViewPager。
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持毛票票。

Android ViewPager实现智能无限循环滚动回绕效果

热门推荐

随机推荐