android 輪播控件的使用

我們經常可以看見輪播的控件，輪播的控件本質上講是ViewPager 和 Scroller 組合起來的控件,也可以使用LoopViewPager 使用。我們先看一種 

先上代碼ViewPager 和 Scroller 組合起來 的方式

import android.content.Context;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.support.v4.view.PagerAdapter;
import android.support.v4.view.ViewPager;
import android.support.v4.view.ViewPager.OnPageChangeListener;
import android.util.AttributeSet;
import android.view.View;
import android.view.ViewGroup;
import android.view.animation.Interpolator;
import android.widget.FrameLayout;
import android.widget.Scroller;



import java.lang.reflect.Field;

public class CarouselFigureView extends FrameLayout implements OnPageChangeListener, IFloorFigureView {

    private static final String TAG = "CarouselFigureView";
    private Context mContext;
    private int bannerCornerRadius;
    /**
     * 輪播圖自動切換時間
     */
    private static final int VIEW_CHANGE_INTERVAL = 2000;
    private static final int VIEW_CHANGE_INTERVAL_RESUME = 2000;
    /**
     * 輪播圖容器
     */
    protected CarouselFigureViewPager pager;
    /**
     * 標記
     */
    protected String id;

    /**
     * 遊標容器
     */
    private ICursorCtrl mCursorContentViewCtrl;
    /**
     * 自動更新Viewpager的令牌
     */
    private long token = -1;
    /**
     * 是否輪播
     */
    private boolean isCarousel;
    /**
     * 是否自動播放
     */
    private boolean isAutoPlay;
    /**
     * 頁面是否不再當前顯示了
     */
    private boolean isPause;
    /**
     * 增加字段控制，detach後停止自動輪播，onDetachedFromWindow不再清除所有消息
     * 原因是部分手機RecyclerView在繪製看不見的樓層後會觸發onDetachedFromWindow，導致setAdapter失敗
     */
    private boolean isDetached;
    private int scrollDuration;
    private Handler handler = new Handler() {
        public void handleMessage(Message msg) {

            if (isPause) {
                return;
            }

            if (isDetached) {
                return;
            }

            if (pager == null || pager.getChildCount() <= 1 || null == pager.getAdapter() || pager.getAdapter().getCount() < 2) {
                return;
            }

            long tag;
            try {
                tag = (Long) msg.obj;
            } catch (Exception e) {
                return;
            }

            if (token - tag != 0) {
                return;
            }

            int position = msg.what;

            if (isCarousel) {
                if (position == 0 && pager.getCurrentItem() != 0) {
                    pager.setCurrentItem(pager.getRealCount() + 1);
                } else if (position == pager.getRealCount() + 1) {
                    pager.setCurrentItem(2);
                } else {
                    pager.setCurrentItem(position + 1);
                }
            } else {
                pager.setCurrentItem((position + 1) % pager.getAdapter().getCount());
            }
        }

    };

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

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

    /**
     * 初始化輪播圖和遊標
     *
     * @param context
     * @param parent             父滾動控件
     * @param pagerHeight        整體高度
     * @param isCarousel         是否輪播
     * @param isAutoPlay         是否自動播放
     * @param cursorMarginBottom 遊標底部的間距(小於或等於0使用默認值)
     */
    public void init(Context context, ViewGroup parent, int pagerHeight, boolean isCarousel, boolean isAutoPlay, int cursorMarginBottom) {
        mContext = context;
        this.isCarousel = isCarousel;
        this.isAutoPlay = isAutoPlay;
        // 初始化輪播圖
        if (pager == null) {
            pager = new CarouselFigureViewPager(mContext);
            LayoutParams pagerParams = new LayoutParams(LayoutParams.MATCH_PARENT, pagerHeight);
            pagerParams.setMargins(0, 0, 0, 0);
            pager.setLayoutParams(pagerParams);

            // 設置輪播圖的翻頁監聽
            pager.setOnPageChangeListener(this);

            addView(pager);
        }
        //初始化遊標
        if (mCursorContentViewCtrl != null) {
            mCursorContentViewCtrl.removeCursor();
            mCursorContentViewCtrl.initCursorContentView(getContext(), pager.getId());
            mCursorContentViewCtrl.onPageSelected(0);
            mCursorContentViewCtrl.setCurrentCursorPosition(0);
        }

        pager.init(parent, isCarousel);
    }

    public void setCursorCtrl( ICursorCtrl cursorCtrl){
        mCursorContentViewCtrl = cursorCtrl;
    }

    /**
     * 初始化輪播圖和遊標（開啓輪播，自動播放）
     *
     * @param context
     * @param parent      父滾動控件
     * @param pagerHeight 整體高度
     */
    public void init(Context context, ViewGroup parent, int pagerHeight) {
        this.init(context, parent, pagerHeight, true, true, 0);
    }

    public void init(Context context, ViewGroup parent, int pagerHeight, boolean isCarousel, boolean isAutoPlay, int cursorMarginBottom, int scrollDuration) {
        init(context, parent, pagerHeight, isCarousel, isAutoPlay, cursorMarginBottom, scrollDuration, true);
    }

    public void init(Context context, ViewGroup parent, int pagerHeight, boolean isCarousel, boolean isAutoPlay, int cursorMarginBottom, int scrollDuration, boolean useCustomScroller) {
        this.scrollDuration = scrollDuration;
        this.init(context, parent, pagerHeight, isCarousel, isAutoPlay, cursorMarginBottom);
        if (scrollDuration > 0 && useCustomScroller) {
            ViewPagerScroller scroller = new ViewPagerScroller(context);
            scroller.setScrollDuration(scrollDuration);
            scroller.initViewPagerScroll(pager);
        }
    }

    /**
     * 綁定數據Adapter
     *
     * @param adapter
     */
    public void setAdapter(PagerAdapter adapter) {
        if (null != adapter) {
            pager.setAdapter(adapter);
            if (mCursorContentViewCtrl != null) {
                mCursorContentViewCtrl.createCursor(pager.getRealCount(),  CarouselFigureView.this, pager.toRealPosition(pager.getCurrentItem()));
            }
            autoChangeViewPagerPosition(VIEW_CHANGE_INTERVAL + this.scrollDuration);
        }
    }

    public void setId(String id) {
        this.id = id;
    }

    public void setPagerPadding(int left, int right, int top, int bottom) {
        if (null != pager) {
            pager.setPadding(left, right, top, bottom);
        }
    }



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

    @Override
    public void onPageSelected(int position) {
        if (mCursorContentViewCtrl != null) {
            mCursorContentViewCtrl.onPageSelected(position);
            mCursorContentViewCtrl.setCurrentCursorPosition(position);
        }
        autoChangeViewPagerPosition(VIEW_CHANGE_INTERVAL + this.scrollDuration );
    }

    /**
     * 自動輪播
     */
    private synchronized void autoChangeViewPagerPosition(int interval) {

        if (pager == null || !isAutoPlay) {
            return;
        }

        token = System.currentTimeMillis();

        Message message = Message.obtain();
        message.what = pager.getCurrentItem();
        message.obj = token;

        handler.sendMessageDelayed(message, interval);
    }

    @Override
    public void onPageScrollStateChanged(int state) {

    }

    public void onPause() {
        token = System.currentTimeMillis();
        isPause = true;
    }

    public void onResume() {
        isPause = false;
        autoChangeViewPagerPosition(VIEW_CHANGE_INTERVAL_RESUME);
    }

    public void toFirstItem() {
        post(new Runnable() {
            @Override
            public void run() {
                if (null == pager || null == pager.getAdapter()) {
                    return;
                }
                if (pager.getAdapter().getCount() > 1 && isCarousel) {
                    pager.setCurrentItem(1, false);
                } else {
                    pager.setCurrentItem(0, false);
                }
            }
        });
    }

    /**
     * 只有圖片的輪播圖，設置回調
     *
     * @param listener
     */
    @Override
    public void setCarouseFigureImageAdapterListener(final CarouseFigureImagePagerAdapter.CarouseFigureImageAdapterListener listener) {
        if (null != pager && null != listener) {
            if (Looper.myLooper() != Looper.getMainLooper()) {
                handler.post(new Runnable() {
                    @Override
                    public void run() {
                        setCarouseFigureImagePagerAdapter(listener);
                    }
                });
            } else {
                setCarouseFigureImagePagerAdapter(listener);
            }
        }
    }

    private void setCarouseFigureImagePagerAdapter(CarouseFigureImagePagerAdapter.CarouseFigureImageAdapterListener listener) {
        pager.setAdapter(new CarouseFigureImagePagerAdapter(mContext, isCarousel, bannerCornerRadius, listener));
        if (mCursorContentViewCtrl != null) {
            mCursorContentViewCtrl.createCursor(pager.getRealCount(),  CarouselFigureView.this, pager.toRealPosition(pager.getCurrentItem()));
        }
        autoChangeViewPagerPosition(VIEW_CHANGE_INTERVAL + this.scrollDuration);
    }

    @Override
    protected void onAttachedToWindow() {
        isDetached = false;
        super.onAttachedToWindow();
    }

    @Override
    protected void onDetachedFromWindow() {
        isDetached = true;
        super.onDetachedFromWindow();
//        handler.removeCallbacksAndMessages(null);
    }

    public class ViewPagerScroller extends Scroller {
        private int mScrollDuration = 2000;             

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

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

        /**
         * 設置速度速度
         *
         * @param duration
         */
        public void setScrollDuration(int duration) {
            this.mScrollDuration = duration;
        }

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

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

        public void initViewPagerScroll(ViewPager viewPager) {
            try {
                Field mScroller = ViewPager.class.getDeclaredField("mScroller");
                mScroller.setAccessible(true);
                mScroller.set(viewPager, this);
            } catch (Exception e) {
                OKLog.e(TAG, e);
            }
        }
    }

    /**
     * 設置輪播左右圖片可見，並設置間距
     *
     * @param margin     左右頁面可見寬度
     * @param pageMargin page間距
     */
    public void setPagerOffset(int margin, int pageMargin) {
        if (pager != null) {
            pager.setClipToPadding(false);
            pager.setPadding(margin, 0, margin, 0);
            pager.setPageMargin(pageMargin);
        }
    }

    /**
     * 設置對外獲取viewPager的方法，便於屏幕切換尺寸時，可以動態修改view高度
     *
     * @return viewpager
     */
    public View getViewPager() {
        return pager;
    }

    /**
     * banner圖的圓角
     *
     * @param bannerCornerRadius
     */
    public void setBannerCornerRadius(int bannerCornerRadius) {
        this.bannerCornerRadius = bannerCornerRadius;
    }

    public void setViewPagerScroller(Scroller scroller) {
        try {
            Field scrollerField = ViewPager.class.getDeclaredField("mScroller");
            scrollerField.setAccessible(true);
            scrollerField.set(getViewPager(), scroller);
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }

    public static class CustomDurationScroller extends Scroller {
        public int duration = 500;

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

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

        public void setCustomDuration(int duration) {
            this.duration = duration;
        }
    }
}

我們在使用的過程中，主意  autoChangeViewPagerPosition(VIEW_CHANGE_INTERVAL + this.scrollDuration);

的時間要比  this.scrollDuration 的時間要長，不然實現不了輪播，這個地方是遇到的坑。

我們看到在View 中主要是viewPager 和 開放的遊標接口

我們先看下CarouselFigureViewPager，我們看下具體實現

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.View.OnTouchListener;
import android.view.ViewGroup;


public class CarouselFigureViewPager extends ViewPager implements OnTouchListener {

    private static final String TAG = "CarouselFigureViewPager";

    private ViewGroup parent;

    /**
     * 頁面變化監聽
     */
    private OnPageChangeListener mOuterPageChangeListener;
    private OnTouchListener onTouchListener;

    private boolean mFirstLayout = true;

    /**
     * 是否輪播
     */
    protected boolean isCarousel = false;

    private boolean mOnTouchFlag = false;

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

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

    public void init(ViewGroup parent, boolean isCarousel) {
        this.parent = parent;
        this.isCarousel = isCarousel;
        super.setOnTouchListener(this);
        super.setOnPageChangeListener(onPageChangeListener);
    }

   
    public void setOnTouchFlag(boolean flag) {
        mOnTouchFlag = flag;
    }

    @Override
    public boolean onTouch(View v, MotionEvent event) {
        if (mOnTouchFlag) {
            return onTouchEvent(event);
        }
        if (onTouchListener != null) {
            onTouchListener.onTouch(v, event);
        }
        switch (event.getAction()) {
            case MotionEvent.ACTION_CANCEL:
            case MotionEvent.ACTION_UP:
                if (parent != null) {
                    parent.requestDisallowInterceptTouchEvent(false);
                }
                if (onTouchListener != null) {
                    onTouchListener.onTouch(v, event);
                }
                break;
            default:
                if (parent != null) {
                    parent.requestDisallowInterceptTouchEvent(true);
                }
                break;
        }

        try {
            onTouchEvent(event);
        } catch (Throwable e) {
            if (OKLog.E) {
                OKLog.e(TAG, e);
            }
        }

        return true;
    }

    @Override
    public void setAdapter(PagerAdapter adapter) {
        super.setAdapter(adapter);
        if (adapter != null && isCarousel && adapter.getCount() > 1) {
            setCurrentItem(1, false);
        }
    }

    @Override
    protected void onAttachedToWindow() {
        if (mFirstLayout) {
            super.onAttachedToWindow();
        }
        mFirstLayout = false;
    }

    @Override
    public void setOnPageChangeListener(OnPageChangeListener listener) {
        mOuterPageChangeListener = listener;
    }

    @Override
    public void setOnTouchListener(OnTouchListener l) {
        this.onTouchListener = l;
    }

    private OnPageChangeListener onPageChangeListener = new OnPageChangeListener() {
        private float mPreviousOffset = -1;
        private float mPreviousPosition = -1;

        @Override
        public void onPageSelected(int position) {
            int realPosition = toRealPosition(position);
            if (mPreviousPosition != realPosition) {
                mPreviousPosition = realPosition;
                if (mOuterPageChangeListener != null) {
                    mOuterPageChangeListener.onPageSelected(realPosition);
                }
            }
        }

        @Override
        public void onPageScrolled(int position, float positionOffset, int positionOffsetPixels) {
         if (isCarousel && null != getAdapter() && getAdapter().getCount() > 3) {
                final int nextPosition = getEdgeNextPosition(position);
               if (positionOffset == 0 && mPreviousOffset == 0
                       && (position == 0 || position == getAdapter().getCount() - 1)) {
                    post(new Runnable() {
                        @Override
                        public void run() {
                            setCurrentItem(nextPosition, false);
                        }
                    });
          }
            }

            mPreviousOffset = positionOffset;
            int realPosition = toRealPosition(position);
            if (mOuterPageChangeListener != null) {
                if (null != getAdapter() && (position != 0 || position != getAdapter().getCount() - 1)) {
                    mOuterPageChangeListener.onPageScrolled(realPosition, positionOffset, positionOffsetPixels);
                } else {
                    if (positionOffset > .5) {
                        mOuterPageChangeListener.onPageScrolled(0, 0, 0);
                    } else {
                        mOuterPageChangeListener.onPageScrolled(realPosition, 0, 0);
                    }
                }
            }
        }

        @Override
        public void onPageScrollStateChanged(int state) {
            if (null != getAdapter() && isCarousel && getAdapter().getCount() > 3) {
                int position = getCurrentItem();
                if (state == ViewPager.SCROLL_STATE_IDLE && (position == 0 || position == getAdapter().getCount() - 1)) {
                    int nextPosition = getEdgeNextPosition(position);
                    setCurrentItem(nextPosition, false);
                }
            }
            if (mOuterPageChangeListener != null) {
                mOuterPageChangeListener.onPageScrollStateChanged(state);
            }
        }

    };

    /**
     * 獲取實際位置，即圓點位置
     *
     * @param position 當前位置
     */
    public int toRealPosition(int position) {
        if (null == getAdapter()) {
            return 0;
        }
        if (!isCarousel) {
            return position;
        }
        int realCount = getRealCount();
        if (realCount == 0)
            return 0;
        int realPosition = (position - 1) % realCount;
        if (realPosition < 0)
            realPosition += realCount;

        return realPosition;
    }

    /**
     * @return 真實個數
     */
    public int getRealCount() {
        if (null == getAdapter()) {
            return 0;
        }
        if (isCarousel && getAdapter().getCount() > 3) {
            return getAdapter().getCount() - 2;
        }
        return getAdapter().getCount();
    }

    /**
     * 邊緣位置獲取下一個位置
     *
     * @param position 當前位置
     * @return
     */
    private int getEdgeNextPosition(int position) {
        int nextPosition = position;
        if (isCarousel && getRealCount() > 1) {
            if (position == 0) {
                nextPosition = getRealCount();
            } else if (position == getRealCount() + 1) {
                nextPosition = 1;
            }
        }
        return nextPosition;
    }

    @Override
    public boolean dispatchTouchEvent(MotionEvent ev) {
        switch (ev.getAction()) {
            case MotionEvent.ACTION_DOWN:
                if (onTouchListener != null) {
                    onTouchListener.onTouch(null, ev);
                }
                break;
            default:
            	break;
        }
        return super.dispatchTouchEvent(ev);
    }

}

我們一般會自定義遊標，這裏給個實現遊標的例子

 

import android.content.Context;
import android.view.Gravity;
import android.view.View;
import android.view.ViewGroup;
import android.view.ViewParent;
import android.widget.FrameLayout;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.RelativeLayout;

import com.facebook.drawee.view.SimpleDraweeView;



/**
 * @author hubenkui
 * @date: 2019-08-07 11:49
 */
public class HomeBannerCursorImpl implements ICursorCtrl {


    /**
     * 遊標容器
     */
    private LinearLayout cursorContent;

    /**
     * 上一次的遊標地址
     */
    private int oldCursorPosition = 0;

    private int curPosition = 0;

    private int cursorWidth = 4, cursorHeight = 4;
    private int cursorSpace = 2;

    int cursorMarginBottom = 0;
    int highLightId;
    int normalId;

    @Override
    public void initCursorContentView(Context c, int viewId) {
        if (cursorContent == null) {
            cursorContent = new LinearLayout(c);
            FrameLayout.LayoutParams cursorParams = new FrameLayout.LayoutParams(FrameLayout.LayoutParams.WRAP_CONTENT, FrameLayout.LayoutParams.WRAP_CONTENT);
            //cursorParams.setMargins(0, 0, 0, cursorMarginBottom > 0 ? cursorMarginBottom : 6);
            cursorParams.setMargins(0, 0, 0, cursorMarginBottom);
            cursorParams.gravity = Gravity.BOTTOM | Gravity.CENTER_HORIZONTAL;
            cursorContent.setPadding(0, 0, 0, 0);
            cursorContent.setOrientation(LinearLayout.HORIZONTAL);
            cursorContent.setLayoutParams(cursorParams);
        }
    }

    @Override
    public void createCursor(int size, ViewGroup vp, int currentItemPosition) {

        if (size < 1) { // 如果沒有數據，就不要顯示輪播圖了
            vp.setVisibility(View.GONE);
            return;
        }

        if (cursorContent == null) return;

        if (vp.getVisibility() == View.GONE) {
            vp.setVisibility(View.VISIBLE);
        }

        if (size < 2) {
            cursorContent.setVisibility(View.GONE);
            return;
        }
        if (cursorContent.getVisibility() == View.GONE) {
            cursorContent.setVisibility(View.VISIBLE);
        }

        cursorContent.removeAllViews();
        final LinearLayout.LayoutParams params = new LinearLayout.LayoutParams(
                cursorWidth, cursorHeight);
        params.gravity = Gravity.CENTER;
      //  params.setMargins(0, 0, cursorSpace, 0);
        for (int i = 0; i < size; i++) {
            SimpleDraweeView cursorView = new SimpleDraweeView(cursorContent.getContext());
            cursorView.setLayoutParams(params);
            cursorView.setScaleType(ImageView.ScaleType.FIT_CENTER);
            cursorView.setImageResource(normalId);
            cursorContent.addView(cursorView);
        }
        openLight(currentItemPosition);
        if (cursorContent.getParent() == null) {
            vp.addView(cursorContent);
        }
    }

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

    }

    @Override
    public void onPageSelected(int position) {
        closeLight(oldCursorPosition);
        openLight(position);
    }


    /**
     * 將一個遊標的顏色設置爲高亮顏色
     *
     * @param index
     */
    private void openLight(int index) {
        if ((cursorContent != null) && (index >= 0)) {
            final ImageView v = (ImageView) cursorContent.getChildAt(index);
            if (v != null) {
                v.setImageResource(highLightId);
                LinearLayout.LayoutParams params = (LinearLayout.LayoutParams) v.getLayoutParams();
                if (params != null){
                    params.height = cursorWidth;
                    params.width = DPIUtil.dip2px(8);
                    v.setLayoutParams(params);
                }
            }
            curPosition = index;
        }
    }

    /**
     * 將一個遊標的顏色設置爲普通顏色
     *
     * @param index
     */
    private void closeLight(int index) {
        if ((cursorContent != null) && (index >= 0)) {
            final ImageView v = (ImageView) cursorContent.getChildAt(index);
            if (v != null) {
                v.setImageResource(normalId);
                LinearLayout.LayoutParams params = (LinearLayout.LayoutParams) v.getLayoutParams();
                if (params != null){
                    params.height = cursorWidth;
                    params.width = cursorWidth
                    ;
                    v.setLayoutParams(params);
                }
            }
        }
    }

    @Override
    public void setCurrentCursorPosition(int position) {
        oldCursorPosition = position;
    }

    @Override
    public boolean equalsOldCursorPosition(int position) {
        return oldCursorPosition == position;
    }

    @Override
    public int getCurPosition() {
        return curPosition;
    }

    @Override
    public void updateCursorBottomMargin(int cursorMarginBottom) {
        if (cursorContent != null) {
            ViewGroup.LayoutParams vplp = cursorContent.getLayoutParams();
            if ((vplp != null) && (vplp instanceof RelativeLayout.LayoutParams)) {
                RelativeLayout.LayoutParams rllp = (RelativeLayout.LayoutParams) vplp;
                rllp.setMargins(0, 0, 0, cursorMarginBottom);
                cursorContent.setLayoutParams(rllp);
            }
        }
    }

    @Override
    public void showCursorContent() {
        if (cursorContent != null) {
            cursorContent.setVisibility(View.VISIBLE);
        }
    }

    @Override
    public void hideCursorContent() {
        if (cursorContent != null) {
            cursorContent.setVisibility(View.GONE);
        }
    }

    @Override
    public void removeCursor() {
        if (null == cursorContent) {
            return;
        }
        cursorContent.removeAllViews();
        ViewParent parent = cursorContent.getParent();
        if (null != parent) {
            ((ViewGroup) parent).removeView(cursorContent);
        }
    }

    @Override
    public View getCursorView() {
        return null;
    }

    @Override
    public void setCursorStyle(int bottomMargin, int hId, int nId) {
        cursorMarginBottom = bottomMargin;
        highLightId = hId;
        normalId = nId;
    }
}

我們看下在代碼中是如何使用

 ICursorCtrl cursorCtrl = new HomeBannerCursorImpl();
        cursorCtrl.setCursorStyle(DPIUtil.dip2px(5), R.drawable.banner_light_icon, R.drawable.banner_normal_icon);
        mLoopViewPager.setCursorCtrl(cursorCtrl);
        mLoopViewPager.setBannerCornerRadius(DPIUtil.dip2px(5));
        mLoopViewPager.init(mContext, mViewPageRootView, DPIUtil.dip2px(100), true, entity.content.size() > 1, DPIUtil.dip2px(1), entity.cfg != null ? entity.cfg.slip_time : 4000);
        mLoopViewPager.setCarouseFigureImageAdapterListener(new CarouseFigureImagePagerAdapter.CarouseFigureImageAdapterListener() {
            @Override
            public int getCount() {
                
            }

            @Override
            public String getImageUrl(int position) {
                
            }

            @Override
            public void onClick(int position) {
              
            @Override
            public JDDisplayImageOptions getJDDisplayImageOptions() {
                return null;
            }
        });

我們看到這個地方是和imageView 強綁定的，我們看下

import android.content.Context;
import android.graphics.Bitmap;
import android.support.v4.view.PagerAdapter;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ImageView;

import com.facebook.drawee.view.SimpleDraweeView;


public class CarouseFigureImagePagerAdapter extends PagerAdapter {
    protected final static int LAST_URL = R.id.image_last_url;
    private Context context;
    private int cornerRadius;
    /**
     * 是否輪播
     */
    private boolean isCarousel;
    private CarouseFigureImageAdapterListener imageAdapterListener;

    private boolean isAllChange;
    /**
     * 焦點圖緩存
     */
    private ImageView first;
    private ImageView last;
    protected DisplayImageOptions displayOptions;

    public CarouseFigureImagePagerAdapter(Context c, boolean isCarousel, CarouseFigureImageAdapterListener listener) {
        this(c, isCarousel, 0, listener);
    }

    public CarouseFigureImagePagerAdapter(Context c, boolean isCarousel, int cornerRadius, CarouseFigureImageAdapterListener listener) {
        context = c;
        this.isCarousel = isCarousel;
        imageAdapterListener = listener;
        this.cornerRadius = cornerRadius;
        initImage();
    }

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

    /**
     * 所有數據發生變化
     *
     * @param isAllChange
     */
    public void setAllChanged(boolean isAllChange) {
        this.isAllChange = isAllChange;
    }

    @Override
    public int getItemPosition(Object object) {
        if (isAllChange) {
            return POSITION_NONE;
        } else {
            return POSITION_UNCHANGED;
        }
    }

    @Override
    public int getCount() {
        if (imageAdapterListener != null) {
            return imageAdapterListener.getCount() + (isTrueCarousel() ? 2 : 0);
        }
        return 0;
    }

    private boolean isTrueCarousel() {
        if (imageAdapterListener != null && isCarousel) {
            return imageAdapterListener.getCount() >= 2;
        }
        return false;
    }

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

    private void initImage() {
        if (!isTrueCarousel()) {
            return;
        }
        if (first == null) {
            first = getImageView();
        }
        if (last == null) {
            last = getImageView();
        }

        //初始化最後一張，防止第一次手動向左滑的閃屏
        displayImage(last, imageAdapterListener.getImageUrl(imageAdapterListener.getCount() - 1), imageAdapterListener.getDisplayImageOptions());
    }

    protected int getRealIndex(int position) {
        int index = position;
        if (isCarousel && imageAdapterListener.getCount() > 1) {
            index = (position - 1) % imageAdapterListener.getCount();
            if (index < 0)
                index += imageAdapterListener.getCount();
        }
        return index;
    }

    private ImageView getImageView() {
        ImageView imageView = new SimpleDraweeView(context);

        imageView.setPadding(0, 0, 0, 0);
        imageView.setScaleType(ImageView.ScaleType.CENTER_CROP);
        imageView.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                if (!NetUtils.isNetworkAvailable()) {
                    return;
                }
                int position = getRealIndex(v.getId());
                imageAdapterListener.onClick(position);
            }
        });
        return imageView;
    }

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

    @Override
    public Object instantiateItem(ViewGroup container, int position) {
        ImageView imageView;
        try {
            if (isCarousel && first != null && position == 1) {
                imageView = first;
            } else if (isCarousel && last != null && position == getCount() - 2) {
                imageView = last;
            } else {
                imageView = getImageView();
            }
            imageView.setId(position);
            container.addView(imageView);

            displayImage(imageView, imageAdapterListener.getImageUrl(getRealIndex(position)), imageAdapterListener.getDisplayImageOptions());
        } catch (Exception e) {
            imageView = new SimpleDraweeView(context);
        }
        if (isAllChange) {
            isAllChange = false;
        }
        return imageView;
    }

    

    public interface CarouseFigureImageAdapterListener {
        int getCount();

        String getImageUrl(int position);

        void onClick(int position);

        DisplayImageOptions getDisplayImageOptions();
    }

}