Android--ViewPager----完美轮播

效果图：



一：代码使用

MainActivity:

public class MainActivity extends AppCompatActivity {
String url = "https://img1.doubanio.com/view/photo/photo/public/p2328130909.jpg";

List<String> urls = new ArrayList<>();
AutoScrollViewPager viewPager;
LinearLayout container;

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
initImage();
}

public void initImage() {
viewPager = (AutoScrollViewPager) findViewById(R.id.viewpager);
container = (LinearLayout) findViewById(R.id.container);
urls.add(url);
urls.add(url);
urls.add(url);
urls.add(url);
showTimeWheel(urls);
}

public void showTimeWheel(List<String> urls) {
viewPager.setAdapter(new TimePagerAdapter(this, urls));
viewPager.setOnPointIndex(urls.size(), container);
//开始滚动
viewPager.startAutoScroll();
}

@Override
public void onPause() {
super.onPause();
viewPager.stopAutoScroll();
}

@Override
public void onResume() {
super.onResume();
viewPager.startAutoScroll();
}

}

activity_main:

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
tools:context="com.erhu.myviewpager.MainActivity">

<com.erhu.view.AutoScrollViewPager
android:id="@+id/viewpager"
android:src="@mipmap/ic_launcher"
android:layout_width="wrap_content"
android:layout_height="wrap_content" />

<LinearLayout
android:id="@+id/container"
android:layout_width="match_parent"
android:layout_height="40px"
android:layout_alignParentBottom="true"
android:gravity="center"
android:orientation="horizontal" />
</RelativeLayout>

TimePagerAdapter:

public class TimePagerAdapter extends ImagePagerAdapter<String> {
Context context;

public TimePagerAdapter(Context context, List<String> urls) {
super(context, urls);
this.context = context;
}

@Override
public void setImageView(ImageView imageView, String coupon) {
// 使用ImageLoader进行图片下载
ImageLoader.getInstance().displayImage(coupon, imageView);
imageView.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
//针对每个view的图片操作
}
});

}
}

二：实现

RecycleGBin:

public class RecycleBin {

private View[] activeViews = new View[0];
private int[] activeViewTypes = new int[0];

private SparseArray<View>[] scrapViews;

private int viewTypeCount;

private SparseArray<View> currentScrapViews;

public void setViewTypeCount(int viewTypeCount) {
if (viewTypeCount < 1) {
throw new IllegalArgumentException("Can't have a viewTypeCount < 1");
}
SparseArray<View>[] scrapViews = new SparseArray[viewTypeCount];
for (int i = 0; i < viewTypeCount; i++) {
scrapViews[i] = new SparseArray<View>();
}
this.viewTypeCount = viewTypeCount;
currentScrapViews = scrapViews[0];
this.scrapViews = scrapViews;
}

protected boolean shouldRecycleViewType(int viewType) {
return viewType >= 0;
}

View getScrapView(int position, int viewType) {
if (viewTypeCount == 1) {
return retrieveFromScrap(currentScrapViews, position);
} else if (viewType >= 0 && viewType < scrapViews.length) {
return retrieveFromScrap(scrapViews[viewType], position);
}
return null;
}

void addScrapView(View scrap, int position, int viewType) {
if (viewTypeCount == 1) {
currentScrapViews.put(position, scrap);
} else {
scrapViews[viewType].put(position, scrap);
}

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.ICE_CREAM_SANDWICH) {
scrap.setAccessibilityDelegate(null);
}
}

void scrapActiveViews() {
final View[] activeViews = this.activeViews;
final int[] activeViewTypes = this.activeViewTypes;
final boolean multipleScraps = viewTypeCount > 1;

SparseArray<View> scrapViews = currentScrapViews;
final int count = activeViews.length;
for (int i = count - 1; i >= 0; i--) {
final View victim = activeViews[i];
if (victim != null) {
int whichScrap = activeViewTypes[i];

activeViews[i] = null;
activeViewTypes[i] = -1;

if (!shouldRecycleViewType(whichScrap)) {
continue;
}

if (multipleScraps) {
scrapViews = this.scrapViews[whichScrap];
}
scrapViews.put(i, victim);

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.ICE_CREAM_SANDWICH) {
victim.setAccessibilityDelegate(null);
}
}
}

pruneScrapViews();
}

private void pruneScrapViews() {
final int maxViews = activeViews.length;
final int viewTypeCount = this.viewTypeCount;
final SparseArray<View>[] scrapViews = this.scrapViews;
for (int i = 0; i < viewTypeCount; ++i) {
final SparseArray<View> scrapPile = scrapViews[i];
int size = scrapPile.size();
final int extras = size - maxViews;
size--;
for (int j = 0; j < extras; j++) {
scrapPile.remove(scrapPile.keyAt(size--));
}
}
}

static View retrieveFromScrap(SparseArray<View> scrapViews, int position) {
int size = scrapViews.size();
if (size > 0) {
for (int i = 0; i < size; i++) {
int fromPosition = scrapViews.keyAt(i);
View view = scrapViews.get(fromPosition);
if (fromPosition == position) {
scrapViews.remove(fromPosition);
return view;
}
}
int index = size - 1;
View r = scrapViews.valueAt(index);
scrapViews.remove(scrapViews.keyAt(index));
return r;
} else {
return null;
}
}
}

CustomDurationScoller:

public class CustomDurationScroller extends Scroller {

private double scrollFactor =2;

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

public CustomDurationScroller(Context context, Interpolator interpolator) {
super(context, interpolator);
}

public void setScrollDurationFactor(double scrollFactor) {
this.scrollFactor = scrollFactor;
}

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

RecyclingPagerAdapter:

public abstract class RecyclingPagerAdapter extends PagerAdapter {
static final int IGNORE_ITEM_VIEW_TYPE = AdapterView.ITEM_VIEW_TYPE_IGNORE;

private final RecycleBin recycleBin;

public RecyclingPagerAdapter() {
this(new RecycleBin());
}

RecyclingPagerAdapter(RecycleBin recycleBin) {
this.recycleBin = recycleBin;
recycleBin.setViewTypeCount(getViewTypeCount());
}

@Override
public void notifyDataSetChanged() {
recycleBin.scrapActiveViews();
super.notifyDataSetChanged();
}

@Override
public final Object instantiateItem(ViewGroup container, int position) {
int viewType = getItemViewType(position);
View view = null;
if (viewType != IGNORE_ITEM_VIEW_TYPE) {
view = recycleBin.getScrapView(position, viewType);
}
view = getView(position, view, container);
container.addView(view);
return view;
}

@Override
public final void destroyItem(ViewGroup container, int position, Object object) {
View view = (View) object;
container.removeView(view);
int viewType = getItemViewType(position);
if (viewType != IGNORE_ITEM_VIEW_TYPE) {
recycleBin.addScrapView(view, position, viewType);
}
}

@Override
public final boolean isViewFromObject(View view, Object object) {
return view == object;
}

public int getViewTypeCount() {
return 1;
}

public int getItemViewType(int position) {
return 0;
}

public abstract View getView(int position, View convertView, ViewGroup container);
}

ImagePagerApater:

public abstract class ImagePagerAdapter<T> extends RecyclingPagerAdapter {

private Context context;
private List<T> listDatas;

private int size;
private boolean isInfiniteLoop;//是否开启无限循环

public ImagePagerAdapter(Context context, List<T> listDatas) {
this.context = context;
this.listDatas = listDatas;
this.size = ListUtil.getCount(listDatas);
//大于1时，启动轮播
isInfiniteLoop = !(ListUtil.isNotEmpty(listDatas) && listDatas.size() == 1);
}

/**
* @param isInfiniteLoop 是否开启无限循环  默认>1时开启
*/
public ImagePagerAdapter(Context context, List<T> listDatas, boolean isInfiniteLoop) {
this.context = context;
this.listDatas = listDatas;
this.size = ListUtil.getCount(listDatas);
this.isInfiniteLoop = isInfiniteLoop;
}

@Override
public int getCount() {
return isInfiniteLoop ? Integer.MAX_VALUE : ListUtil.getCount(listDatas);
}

private int getPosition(int position) {
return isInfiniteLoop ? position % size : position;
}

@Override
public View getView(int position, View view, ViewGroup container) {
ViewHolder holder;
if (view == null) {
holder = new ViewHolder();
view = holder.imageView = new ImageView(context);
holder.imageView.setScaleType(ImageView.ScaleType.FIT_XY);
view.setTag(holder);
} else {
holder = (ViewHolder) view.getTag();
}
setImageView(holder.imageView, listDatas.get(getPosition(position)));
return view;
}

public abstract void setImageView(ImageView imageView, T t);

private static class ViewHolder {
ImageView imageView;
}

public Context getContext() {
return context;
}

public void setContext(Context context) {
this.context = context;
}
}

AutoScrollViewPager:

public class AutoScrollViewPager extends ViewPager {

public static final int DEFAULT_INTERVAL = 4000;//默认的时间间隔

public static final int LEFT = 0;
public static final int RIGHT = 1;

public static final int SLIDE_BORDER_MODE_NONE = 0;

public static final int SLIDE_BORDER_MODE_CYCLE = 1;

public static final int SLIDE_BORDER_MODE_TO_PARENT = 2;

private long interval = DEFAULT_INTERVAL;

private int direction = RIGHT;

private boolean isCycle = true;

private boolean stopScrollWhenTouch = true;

private int slideBorderMode = SLIDE_BORDER_MODE_NONE;

private boolean isBorderAnimation = true;

private Handler handler;
private boolean isAutoScroll = true;
private boolean isStopByTouch = false;
private float touchX = 0f, downX = 0f;
private CustomDurationScroller scroller = null;

public static final int SCROLL_WHAT = 0;

public AutoScrollViewPager(Context paramContext) {
super(paramContext);
init();
}

public AutoScrollViewPager(Context paramContext, AttributeSet paramAttributeSet) {
super(paramContext, paramAttributeSet);
init();
}

private void init() {
handler = new MyHandler();
setViewPagerScroller();
}

public void startAutoScroll() {
isAutoScroll = true;
sendScrollMessage(interval);
}

public void startAutoScroll(int delayTimeInMills) {
isAutoScroll = true;
sendScrollMessage(delayTimeInMills);
}

public void stopAutoScroll() {
isAutoScroll = false;
handler.removeMessages(SCROLL_WHAT);
}

public void setScrollDurationFactor(double scrollFactor) {
scroller.setScrollDurationFactor(scrollFactor);
}

private void sendScrollMessage(long delayTimeInMills) {
handler.removeMessages(SCROLL_WHAT);
handler.sendEmptyMessageDelayed(SCROLL_WHAT, delayTimeInMills);
}

private void setViewPagerScroller() {
try {
Field scrollerField = ViewPager.class.getDeclaredField("mScroller");
scrollerField.setAccessible(true);
Field interpolatorField = ViewPager.class.getDeclaredField("sInterpolator");
interpolatorField.setAccessible(true);

scroller = new CustomDurationScroller(getContext(), (Interpolator) interpolatorField.get(null));
scrollerField.set(this, scroller);
} catch (Exception e) {
e.printStackTrace();
}
}

public void scrollOnce() {
PagerAdapter adapter = getAdapter();
int currentItem = getCurrentItem();
int totalCount;
if (adapter == null || (totalCount = adapter.getCount()) <= 1) {
return;
}

int nextItem = (direction == LEFT) ? --currentItem : ++currentItem;
if (nextItem < 0) {
if (isCycle) {
setCurrentItem(totalCount - 1, isBorderAnimation);
}
} else if (nextItem == totalCount) {
if (isCycle) {
setCurrentItem(0, isBorderAnimation);
}
} else {
setCurrentItem(nextItem, true);
}
}

@Override
public boolean onTouchEvent(MotionEvent ev) {
if (stopScrollWhenTouch) {
if (ev.getAction() == MotionEvent.ACTION_DOWN && isAutoScroll) {
isStopByTouch = true;
stopAutoScroll();
} else if (ev.getAction() == MotionEvent.ACTION_UP && isStopByTouch) {
startAutoScroll();
}
}

if (slideBorderMode == SLIDE_BORDER_MODE_TO_PARENT || slideBorderMode == SLIDE_BORDER_MODE_CYCLE) {
touchX = ev.getX();
if (ev.getAction() == MotionEvent.ACTION_DOWN) {
downX = touchX;
}
int currentItem = getCurrentItem();
PagerAdapter adapter = getAdapter();
int pageCount = adapter == null ? 0 : adapter.getCount();

if ((currentItem == 0 && downX <= touchX) || (currentItem == pageCount - 1 && downX >= touchX)) {
if (slideBorderMode == SLIDE_BORDER_MODE_TO_PARENT) {
getParent().requestDisallowInterceptTouchEvent(false);
} else {
if (pageCount > 1) {
setCurrentItem(pageCount - currentItem - 1, isBorderAnimation);
}
getParent().requestDisallowInterceptTouchEvent(true);
}
return super.onTouchEvent(ev);
}
}
getParent().requestDisallowInterceptTouchEvent(true);
return super.onTouchEvent(ev);
}

public class MyHandler extends Handler {
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
switch (msg.what) {
case SCROLL_WHAT:
scrollOnce();
sendScrollMessage(interval);
break;
default:
break;
}
}
}

public long getInterval() {
return interval;
}

public void setInterval(long interval) {
this.interval = interval;
}

public int getDirection() {
return (direction == LEFT) ? LEFT : RIGHT;
}

public void setDirection(int direction) {
this.direction = direction;
}

public boolean isCycle() {
return isCycle;
}

public void setCycle(boolean isCycle) {
this.isCycle = isCycle;
}

public boolean isStopScrollWhenTouch() {
return stopScrollWhenTouch;
}

public void setStopScrollWhenTouch(boolean stopScrollWhenTouch) {
this.stopScrollWhenTouch = stopScrollWhenTouch;
}

public int getSlideBorderMode() {
return slideBorderMode;
}

public void setSlideBorderMode(int slideBorderMode) {
this.slideBorderMode = slideBorderMode;
}

public boolean isBorderAnimation() {
return isBorderAnimation;
}

public void setBorderAnimation(boolean isBorderAnimation) {
this.isBorderAnimation = isBorderAnimation;
}

private LinearLayout container;//点的父布局
private LinearLayout.LayoutParams paramsSmall;//小点属性
private List<View> points;//点集合
private int size;// 实际item个数
private int pointNormal;//没有选中的点drawable
private int pointSelect;//选中的点drawable

public void setOnPointIndex(int size, LinearLayout container, int pointNormal, int pointSelect) {
this.size = size;
this.container = container;
this.pointNormal = pointNormal;
this.pointSelect = pointSelect;
//大于1,才显示point 进行轮播
if (this.container == null) {
stopAutoScroll();
return;
}
if (this.size <= 1) {
stopAutoScroll();
this.container.setVisibility(GONE);
return;
}
points = new ArrayList<>();
paramsSmall = new LinearLayout.LayoutParams(20, 20);
paramsSmall.setMargins(10, 10, 10, 10);
setPoint();
addOnPageChangeListener(new OnPageChangeListener() {
@Override
public void onPageScrolled(int position, float positionOffset, int positionOffsetPixels) {
}

@Override
public void onPageSelected(int position) {
initPointColor(getCurrentItem());
}

@Override
public void onPageScrollStateChanged(int state) {
}
});
}

public void setOnPointIndex(int size, LinearLayout container) {
setOnPointIndex(size, container, R.mipmap.ic_point_pre_3x, R.mipmap.ic_point_3x);
}

private void setPoint() {
container.removeAllViews();
points.clear();
for (int i = 0; i < size; i++) {
View view = new View(getContext());//点
view.setLayoutParams(paramsSmall);
container.addView(view);
points.add(view);
}
initPointColor(0);
}

//初始化底部指示点颜色
public void initPointColor(int index) {
for (int i = 0; i < size; i++) {
points.get(i).setBackgroundResource(pointNormal);
points.get(i).setLayoutParams(paramsSmall);
}
points.get(index % size).setBackgroundResource(pointSelect);
points.get(index % size).setLayoutParams(paramsSmall);
}
}

ListUtil:工具类:

/**
* List工具类
*/
public class ListUtil {
/**
* 判断集合list数据是否为空
*/
public static boolean isEmpty(List<?> list) {
if (list == null || list.size() == 0)
return true;
return false;
}

/**
* 判断集合list数据是否为非空
*/
public static <T> boolean isNotEmpty(List<T> list) {
return !isEmpty(list);
}

/**
* 清空集合
*/
public static void clearList(List<?> list) {
if (!isEmpty(list)) {
list.clear();
}
}

/**
* 获取集合list数据长度
*/
public static <T> int getCount(List<T> list) {
return list == null ? 0 : list.size();
}
}

三：实现：

1–：并没有使用线程池或者定时器定时执行任务状态，而是通过Handler发送消息来完成滚动，在完成滚动之后，再发送一个消息delay:

public class MyHandler extends Handler {
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
switch (msg.what) {
case SCROLL_WHAT:
scrollOnce();
sendScrollMessage(interval);
break;
default:
break;
}
}
}

public void scrollOnce() {
PagerAdapter adapter = getAdapter();
int currentItem = getCurrentItem();
int totalCount;
if (adapter == null || (totalCount = adapter.getCount()) <= 1) {
return;
}

int nextItem = (direction == LEFT) ? --currentItem : ++currentItem;
if (nextItem < 0) {
if (isCycle) {
setCurrentItem(totalCount - 1, isBorderAnimation);
}
} else if (nextItem == totalCount) {
if (isCycle) {
setCurrentItem(0, isBorderAnimation);
}
} else {
setCurrentItem(nextItem, true);
}
}

private void sendScrollMessage(long delayTimeInMills) {
handler.removeMessages(SCROLL_WHAT);
handler.sendEmptyMessageDelayed(SCROLL_WHAT, delayTimeInMills);
}

public void startAutoScroll(int delayTimeInMills) {
isAutoScroll = true;
sendScrollMessage(delayTimeInMills);
}

2–:对于ViewPager嵌套导致子ViewPager无法触摸问题通过在子ViewPager中：

getParent().requestDisallowInterceptTouchEvent(true);

禁止父控件对TouchEvent控制的。

3–:ViewPager的滑动是通过反射方式重新设置Scroller,改变startScroll的间隔时间完成的。

调用如下方法可以完成设置：

public void setScrollDurationFactor(double scrollFactor) {
scroller.setScrollDurationFactor(scrollFactor);
}

四：设置

setInterval(long) 设置自动滚动的间隔时间，单位为毫秒
setDirection(int) 设置自动滚动的方向，默认向右
setCycle(boolean) 是否自动循环轮播，默认为true
setScrollDurationFactor(double) 设置ViewPager滑动动画间隔时间的倍率，达到减慢动画或改变动画速度的效果
setStopScrollWhenTouch(boolean) 当手指碰到ViewPager时是否停止自动滚动，默认为true
setSlideBorderMode(int) 滑动到第一个或最后一个Item的处理方式，支持没有任何操作、轮播以及传递到父View三种模式
setBorderAnimation(boolean) 设置循环滚动时滑动到从边缘滚动到下一个是否需要动画，默认为true