ViewPager无限循环,自动滚动,兼容PageIndicator的ViewPager

1 首先重写Viewpager，实现循环、定时滑动。

package com.example.fullviewpagerdemo;

import android.content.Context;
import android.support.v4.view.PagerAdapter;
import android.support.v4.view.ViewPager;
import android.util.AttributeSet;
import android.view.MotionEvent;
import android.view.View;
import android.view.ViewGroup;

/**
 * 全能Viewpager，自动滚动，循环滑动、分页指示器 更新数据必须调用getMyPagerAdapter,方法获取到的PagerAdapter
 * 
 * 
 * 
 * 2014-4-24 上午9:46:00
 */
public class HeadViewPager extends ViewPager implements Runnable {

private PagerAdapter pagerAdapter;

private static final int POST_DELAYED_TIME = 1000 * 2;
// 手指是否放在上面
private boolean touching;

// 更新数据需要获得myPagerAdapter
private PagerAdapter myPagerAdapter;

public HeadViewPager(Context context, AttributeSet attrs) {
super(context, attrs);
postDelayed(this, POST_DELAYED_TIME);
}

// 对setAdapter的数据进行包装
private class MyPagerAdapter extends PagerAdapter {
private PagerAdapter pa;

public MyPagerAdapter(PagerAdapter pa) {
this.pa = pa;
}

@Override
// 关键之一:修改Count长度
public int getCount() {
return pa.getCount() > 1 ? pa.getCount() + 2 : pa.getCount();
}

@Override
// 这里是关键之二:修改索引(如果不考虑内容问题可以全部加载进数组然后操作更简单)
public Object instantiateItem(ViewGroup container, int position) {

if (position == 0) {
return pa.instantiateItem(container, pa.getCount() - 1);
} else if (position == pa.getCount() + 1) {
return pa.instantiateItem(container, 0);
} else {
return pa.instantiateItem(container, position - 1);
}
}

@Override
public void destroyItem(ViewGroup container, int position, Object object) {
pa.destroyItem(container, position, object);
}

@Override
public boolean isViewFromObject(View arg0, Object arg1) {
return pa.isViewFromObject(arg0, arg1);
}
}

// 包装setOnPageChangeListener的数据
private class MyOnPageChangeListener implements OnPageChangeListener {
private OnPageChangeListener listener;
// 是否已经提前触发了OnPageSelected事件
private boolean alreadyTriggerOnPageSelected;

public MyOnPageChangeListener(OnPageChangeListener listener) {
this.listener = listener;
}

@Override
// 关键之三:
public void onPageScrollStateChanged(int arg0) {
if (arg0 == SCROLL_STATE_IDLE) {
if (getCurrentItem() + 1 == 0) {
setCurrentItem(pagerAdapter.getCount() - 1, false);
} else if (getCurrentItem() + 1 == pagerAdapter.getCount() + 1) {
setCurrentItem(0, false);
}
}

listener.onPageScrollStateChanged(arg0);
}

@Override
public void onPageScrolled(int arg0, float arg1, int arg2) {
listener.onPageScrolled(arg0, arg1, arg2);
}

@Override
// 关键四:
public void onPageSelected(int arg0) {
if (arg0 == 0) {
listener.onPageSelected(pagerAdapter.getCount() - 1);
alreadyTriggerOnPageSelected = true;
} else if (arg0 == pagerAdapter.getCount() + 1) {
listener.onPageSelected(0);
alreadyTriggerOnPageSelected = true;
} else {
if (!alreadyTriggerOnPageSelected) {
listener.onPageSelected(arg0 - 1);
}
alreadyTriggerOnPageSelected = false;
}

}

}

@Override
public void setOnPageChangeListener(OnPageChangeListener listener) {
super.setOnPageChangeListener(listener == null ? null
: new MyOnPageChangeListener(listener));
}

@Override
public void setAdapter(PagerAdapter arg0) {
myPagerAdapter = arg0 == null ? null : new MyPagerAdapter(arg0);
super.setAdapter(myPagerAdapter);

if (arg0 != null && arg0.getCount() != 0) {
setCurrentItem(0, false);
}
this.pagerAdapter = arg0;
}

@Override
// 兼容PageIndicator
public PagerAdapter getAdapter() {
return pagerAdapter;
}

public PagerAdapter getMyPagerAdapter() {
return myPagerAdapter;
}

@Override
public int getCurrentItem() {
return super.getCurrentItem() - 1;
}

@Override
public void setCurrentItem(int item) {
setCurrentItem(item, true);
}

@Override
public void setCurrentItem(int item, boolean smoothScroll) {
super.setCurrentItem(item + 1, smoothScroll);
}

@Override
// 自动滚动关键
public void run() {
if (getAdapter() != null && getAdapter().getCount() > 1 && !touching) {
setCurrentItem(getCurrentItem() + 1, true);
}
postDelayed(this, POST_DELAYED_TIME);
}

@Override
public boolean onTouchEvent(MotionEvent event) {
if (event.getAction() == MotionEvent.ACTION_DOWN) {
this.touching = true;
} else if (event.getAction() == MotionEvent.ACTION_UP
|| event.getAction() == MotionEvent.ACTION_CANCEL) {
this.touching = false;
}

return super.onTouchEvent(event);
}
}

2、分页指示器，从viewpagerindicator开源项目中拷贝出来两个文件，LinePageIndicator、PageIndicator（代码无变化）

/*
 * Copyright (C) 2012 Jake Wharton
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.viewpagerindicator;

import android.content.Context;
import android.content.res.Resources;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.os.Parcel;
import android.os.Parcelable;
import android.support.v4.view.MotionEventCompat;
import android.support.v4.view.ViewConfigurationCompat;
import android.support.v4.view.ViewPager;
import android.util.AttributeSet;
import android.util.TypedValue;
import android.view.MotionEvent;
import android.view.View;
import android.view.ViewConfiguration;

/**
 * Draws a line for each page. The current page line is colored differently than
 * the unselected page lines.
 */
public class LinePageIndicator extends View implements PageIndicator {
private static final int INVALID_POINTER = -1;
// ============================================
// ===================Config===================
// ============================================
// 线条粗细,单位dp
private static final int STROKE_WIDTH = 2;
// 线条长度,单位dp
private static final int LINE_WIDTH = 12;
// 线条间隔,单位dp
private static final int GAP_WIDTH = 4;
// 选中的时候线条颜色
private static final int SELECTED_COLOR = Color.parseColor("#FF33B5E5");
// 没有选中的时候线条颜色
private static final int UN_SELECTED_COLOR = Color.parseColor("#FFBBBBBB");
// ============================================
// =================Config End=================
// ============================================

// 没有选中的时候的画笔
private final Paint mPaintUnselected = new Paint(Paint.ANTI_ALIAS_FLAG);
// 选中的时候的画笔
private final Paint mPaintSelected = new Paint(Paint.ANTI_ALIAS_FLAG);
private ViewPager mViewPager;
private ViewPager.OnPageChangeListener mListener;
// 当前页面
private int mCurrentPage;
// 是否居中
private boolean mCentered = true;
// 线条长度,单位px
private float mLineWidth;
// 线条之间的间隔,单位px
private float mGapWidth;

private int mTouchSlop;
private float mLastMotionX = -1;
private int mActivePointerId = INVALID_POINTER;
private boolean mIsDragging;

public LinePageIndicator(Context context) {
this(context, null);
}

/**
 * dp转px
 * 
 * @param res
 *            android.content.res.Resources
 * @param dp
 * @return
 */
public static int dpToPx(Resources res, int dp) {
return (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, dp, res.getDisplayMetrics());
}

public LinePageIndicator(Context context, AttributeSet attrs) {
super(context, attrs);
if (isInEditMode())
return;

final Resources res = getResources();
mLineWidth = dpToPx(res, LINE_WIDTH);
mGapWidth = dpToPx(res, GAP_WIDTH);
setStrokeWidth(dpToPx(res, STROKE_WIDTH));
mPaintUnselected.setColor(UN_SELECTED_COLOR);
mPaintSelected.setColor(SELECTED_COLOR);

final ViewConfiguration configuration = ViewConfiguration.get(context);
mTouchSlop = ViewConfigurationCompat.getScaledPagingTouchSlop(configuration);
}

public void setCentered(boolean centered) {
mCentered = centered;
invalidate();
}

public boolean isCentered() {
return mCentered;
}

public void setUnselectedColor(int unselectedColor) {
mPaintUnselected.setColor(unselectedColor);
invalidate();
}

public int getUnselectedColor() {
return mPaintUnselected.getColor();
}

public void setSelectedColor(int selectedColor) {
mPaintSelected.setColor(selectedColor);
invalidate();
}

public int getSelectedColor() {
return mPaintSelected.getColor();
}

public void setLineWidth(float lineWidth) {
mLineWidth = lineWidth;
invalidate();
}

public float getLineWidth() {
return mLineWidth;
}

public void setStrokeWidth(float lineHeight) {
mPaintSelected.setStrokeWidth(lineHeight);
mPaintUnselected.setStrokeWidth(lineHeight);
invalidate();
}

public float getStrokeWidth() {
return mPaintSelected.getStrokeWidth();
}

public void setGapWidth(float gapWidth) {
mGapWidth = gapWidth;
invalidate();
}

public float getGapWidth() {
return mGapWidth;
}

@Override
protected void onDraw(Canvas canvas) {
super.onDraw(canvas);

if (mViewPager == null) {
return;
}
final int count = mViewPager.getAdapter().getCount();
if (count == 0) {
return;
}

if (mCurrentPage >= count) {
setCurrentItem(count - 1);
return;
}

final float lineWidthAndGap = mLineWidth + mGapWidth;
final float indicatorWidth = (count * lineWidthAndGap) - mGapWidth;
final float paddingTop = getPaddingTop();
final float paddingLeft = getPaddingLeft();
final float paddingRight = getPaddingRight();

float verticalOffset = paddingTop + ((getHeight() - paddingTop - getPaddingBottom()) / 2.0f);
float horizontalOffset = paddingLeft;
if (mCentered) {
horizontalOffset += ((getWidth() - paddingLeft - paddingRight) / 2.0f) - (indicatorWidth / 2.0f);
}

// Draw stroked circles
for (int i = 0; i < count; i++) {
float dx1 = horizontalOffset + (i * lineWidthAndGap);
float dx2 = dx1 + mLineWidth;
canvas.drawLine(dx1, verticalOffset, dx2, verticalOffset, (i == mCurrentPage) ? mPaintSelected : mPaintUnselected);
}
}

public boolean onTouchEvent(android.view.MotionEvent ev) {
if (super.onTouchEvent(ev)) {
return true;
}
if ((mViewPager == null) || (mViewPager.getAdapter().getCount() == 0)) {
return false;
}

final int action = ev.getAction() & MotionEventCompat.ACTION_MASK;
switch (action) {
case MotionEvent.ACTION_DOWN:
mActivePointerId = MotionEventCompat.getPointerId(ev, 0);
mLastMotionX = ev.getX();
break;

case MotionEvent.ACTION_MOVE: {
final int activePointerIndex = MotionEventCompat.findPointerIndex(ev, mActivePointerId);
final float x = MotionEventCompat.getX(ev, activePointerIndex);
final float deltaX = x - mLastMotionX;

if (!mIsDragging) {
if (Math.abs(deltaX) > mTouchSlop) {
mIsDragging = true;
}
}

if (mIsDragging) {
mLastMotionX = x;
if (mViewPager.isFakeDragging() || mViewPager.beginFakeDrag()) {
mViewPager.fakeDragBy(deltaX);
}
}

break;
}

case MotionEvent.ACTION_CANCEL:
case MotionEvent.ACTION_UP:
if (!mIsDragging) {
final int count = mViewPager.getAdapter().getCount();
final int width = getWidth();
final float halfWidth = width / 2f;
final float sixthWidth = width / 6f;

if ((mCurrentPage > 0) && (ev.getX() < halfWidth - sixthWidth)) {
if (action != MotionEvent.ACTION_CANCEL) {
mViewPager.setCurrentItem(mCurrentPage - 1);
}
return true;
} else if ((mCurrentPage < count - 1) && (ev.getX() > halfWidth + sixthWidth)) {
if (action != MotionEvent.ACTION_CANCEL) {
mViewPager.setCurrentItem(mCurrentPage + 1);
}
return true;
}
}

mIsDragging = false;
mActivePointerId = INVALID_POINTER;
if (mViewPager.isFakeDragging())
mViewPager.endFakeDrag();
break;

case MotionEventCompat.ACTION_POINTER_DOWN: {
final int index = MotionEventCompat.getActionIndex(ev);
mLastMotionX = MotionEventCompat.getX(ev, index);
mActivePointerId = MotionEventCompat.getPointerId(ev, index);
break;
}

case MotionEventCompat.ACTION_POINTER_UP:
final int pointerIndex = MotionEventCompat.getActionIndex(ev);
final int pointerId = MotionEventCompat.getPointerId(ev, pointerIndex);
if (pointerId == mActivePointerId) {
final int newPointerIndex = pointerIndex == 0 ? 1 : 0;
mActivePointerId = MotionEventCompat.getPointerId(ev, newPointerIndex);
}
mLastMotionX = MotionEventCompat.getX(ev, MotionEventCompat.findPointerIndex(ev, mActivePointerId));
break;
}

return true;
}

@Override
public void setViewPager(ViewPager viewPager) {
if (mViewPager == viewPager) {
return;
}
if (mViewPager != null) {
// Clear us from the old pager.
mViewPager.setOnPageChangeListener(null);
}
if (viewPager.getAdapter() == null) {
throw new IllegalStateException("ViewPager does not have adapter instance.");
}
mViewPager = viewPager;
mViewPager.setOnPageChangeListener(this);
mCurrentPage = mViewPager.getCurrentItem();
invalidate();
}

@Override
public void setViewPager(ViewPager view, int initialPosition) {
setViewPager(view);
setCurrentItem(initialPosition);
}

@Override
public void setCurrentItem(int item) {
if (mViewPager == null) {
throw new IllegalStateException("ViewPager has not been bound.");
}
mViewPager.setCurrentItem(item);
mCurrentPage = item;
invalidate();
}

@Override
public void notifyDataSetChanged() {
invalidate();
}

@Override
public void onPageScrollStateChanged(int state) {
if (mListener != null) {
mListener.onPageScrollStateChanged(state);
}
}

@Override
public void onPageScrolled(int position, float positionOffset, int positionOffsetPixels) {
if (mListener != null) {
mListener.onPageScrolled(position, positionOffset, positionOffsetPixels);
}
}

@Override
public void onPageSelected(int position) {
mCurrentPage = position;
invalidate();

if (mListener != null) {
mListener.onPageSelected(position);
}
}

@Override
public void setOnPageChangeListener(ViewPager.OnPageChangeListener listener) {
mListener = listener;
}

@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
setMeasuredDimension(measureWidth(widthMeasureSpec), measureHeight(heightMeasureSpec));
}

/**
 * Determines the width of this view
 * 
 * @param measureSpec
 *            A measureSpec packed into an int
 * @return The width of the view, honoring constraints from measureSpec
 */
private int measureWidth(int measureSpec) {
float result;
int specMode = MeasureSpec.getMode(measureSpec);
int specSize = MeasureSpec.getSize(measureSpec);

if ((specMode == MeasureSpec.EXACTLY) || (mViewPager == null)) {
// We were told how big to be
result = specSize;
} else {
// Calculate the width according the views count
final int count = mViewPager.getAdapter().getCount();
result = getPaddingLeft() + getPaddingRight() + (count * mLineWidth) + ((count - 1) * mGapWidth);
// Respect AT_MOST value if that was what is called for by
// measureSpec
if (specMode == MeasureSpec.AT_MOST) {
result = Math.min(result, specSize);
}
}
return (int) Math.ceil(result);
}

/**
 * Determines the height of this view
 * 
 * @param measureSpec
 *            A measureSpec packed into an int
 * @return The height of the view, honoring constraints from measureSpec
 */
private int measureHeight(int measureSpec) {
float result;
int specMode = MeasureSpec.getMode(measureSpec);
int specSize = MeasureSpec.getSize(measureSpec);

if (specMode == MeasureSpec.EXACTLY) {
// We were told how big to be
result = specSize;
} else {
// Measure the height
result = mPaintSelected.getStrokeWidth() + getPaddingTop() + getPaddingBottom();
// Respect AT_MOST value if that was what is called for by
// measureSpec
if (specMode == MeasureSpec.AT_MOST) {
result = Math.min(result, specSize);
}
}
return (int) Math.ceil(result);
}

@Override
public void onRestoreInstanceState(Parcelable state) {
SavedState savedState = (SavedState) state;
super.onRestoreInstanceState(savedState.getSuperState());
mCurrentPage = savedState.currentPage;
requestLayout();
}

@Override
public Parcelable onSaveInstanceState() {
Parcelable superState = super.onSaveInstanceState();
SavedState savedState = new SavedState(superState);
savedState.currentPage = mCurrentPage;
return savedState;
}

static class SavedState extends BaseSavedState {
int currentPage;

public SavedState(Parcelable superState) {
super(superState);
}

private SavedState(Parcel in) {
super(in);
currentPage = in.readInt();
}

@Override
public void writeToParcel(Parcel dest, int flags) {
super.writeToParcel(dest, flags);
dest.writeInt(currentPage);
}

public static final Parcelable.Creator<SavedState> CREATOR = new Parcelable.Creator<SavedState>() {
@Override
public SavedState createFromParcel(Parcel in) {
return new SavedState(in);
}

@Override
public SavedState[] newArray(int size) {
return new SavedState[size];
}
};
}
}

此时，完成能达到所说效果。

代码出处：http://www.cnblogs.com/moqi2013/p/3547816.html