自滑动的广告位

Banner

添加内容，作为自定义布局添加到主布局中

package com.rednovo.weibo.widget.main;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

import android.content.Context;
import android.content.Intent;
import android.graphics.Bitmap;
import android.util.AttributeSet;
import android.util.Log;
import android.view.GestureDetector;
import android.view.MotionEvent;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ImageView;
import android.widget.RelativeLayout;
import android.widget.Toast;

import com.rednovo.weibo.activity.BannerActivity;
import com.rednovo.weibo.activity.LiveActivity;
import com.rednovo.weibo.activity.NewOtherUserZoneActivity;
import com.rednovo.weibo.activity.StarZoneActivity;
import com.rednovo.weibo.widget.zoomview.HorizonScrollableViewGroup;
import com.xiuba.sdk.cache.ImageCache;
import com.xiuba.sdk.util.StringUtils;
import com.rednovo.weibo.R;
import com.xiuba.lib.cloudapi.BaseRequestCallback;
import com.xiuba.lib.cloudapi.PublicAPI;
import com.xiuba.lib.config.BannerIntentKey;
import com.xiuba.lib.model.ActivityResult;
import com.xiuba.lib.model.BannerResult;
import com.xiuba.lib.model.RoomListResult;
import com.xiuba.lib.utils.CacheUtils;
import com.xiuba.lib.utils.DisplayUtils;
import com.xiuba.lib.utils.LoginUtils;
import com.xiuba.lib.utils.PromptUtils;
import com.xiuba.lib.utils.UserInfoUtils;
import com.xiuba.lib.utils.Utils;

/**
 * Created by CG on 13-10-28.
 *
 * @author ll
 * @version 3.0.0
 */
public class BannerView extends RelativeLayout {

public static String TAG = "BannerView";

/**
 * 关闭悬浮广告接口
 */
public interface OnBannerClosedListener {
    /**
     * 关闭广告
     * @param bannerView bannerView
     */
    public void onBannerClosed(BannerView bannerView);
}

private static final int BANNER_HEIGHT = (DisplayUtils.px2dp(DisplayUtils.getHeightPixels())/10*2);

private static boolean sEnableShowBanner = true;

private HorizonScrollableViewGroup mBannerView;
private OnBannerClosedListener mOnBannerClosedListener;
private boolean mIsInit = false;
private RoomListResult.Data roomdata;

/**
 * 关闭广告
 * @param listener listener
 */
public void setOnBannerEventListener(OnBannerClosedListener listener) {
    mOnBannerClosedListener = listener;
}

/**
 * BannerView
 *
 * @param context context
 */
public BannerView(Context context) {
    super(context);
}

/**
 * BannerView
 *
 * @param context context
 * @param attrs   attrs
 */
public BannerView(Context context, AttributeSet attrs) {
    super(context, attrs);
}

private void init() {
    mBannerView = new HorizonScrollableViewGroup(getContext());
    LayoutParams lp = new LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT);
    final int margin = (int) getResources().getDimension(R.dimen.normal_margin);
    lp.leftMargin = margin;
    lp.rightMargin = margin;
    lp.topMargin = margin;
    //lp.bottomMargin = 20;
    addView(mBannerView, lp);

    final int largeMargin = (int) getResources().getDimension(R.dimen.large_margin);
    final int topMargin = 26;
    lp = new LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT);
    lp.addRule(ALIGN_PARENT_RIGHT);
    //lp.addRule(CENTER_VERTICAL);
    lp.rightMargin = largeMargin;
    lp.topMargin = topMargin;
    mIsInit = true;
    //bannerview关闭按钮去掉
}

/**
 * refresh
 */
public void refresh() {
    if (sEnableShowBanner) {
        PublicAPI.getActivity().execute(new BaseRequestCallback<ActivityResult>() {
            @Override
            public void onRequestSucceed(ActivityResult activityResult) {
                if (activityResult.getDataList().size() > 0) {
                    if (mBannerView == null || mBannerView.getChildCount() == 0) {
                        for (final ActivityResult.Data data : activityResult.getDataList()) {
                            if (!StringUtils.isEmpty(data.getmTagsrc())) {
                                Bitmap picture = CacheUtils.getImageCache().getBitmapFromMemCache(data.getmTagsrc()
                                        , data.getmTagsrc(), DisplayUtils.getWidthPixels(), DisplayUtils.dp2px(BANNER_HEIGHT));
                                if (picture == null) {
                                    CacheUtils.getImageCache().loadImageAsync(data.getmTagsrc()
                                            , DisplayUtils.getWidthPixels(), DisplayUtils.dp2px(BANNER_HEIGHT)
                                            , new ImageCache.Callback() {
                                        @Override
                                        public void imageLoaded(String s, int i, int i2, Bitmap bitmap) {
                                            addBannerImageView(data, bitmap);
                                        }
                                    });
                                } else {
                                    addBannerImageView(data, picture);
                                }
                            }
                        }
                    }
                }
            }

            @Override
            public void onRequestFailed(ActivityResult activityResult) {
            }
        });
    }
}

private void addBannerImageView(final ActivityResult.Data data, Bitmap bitmap) {
    if (!mIsInit) {
        init();
    }
    ImageView imageView = new ImageView(getContext());
    imageView.setTag(data.getmTagsrc());
    imageView.setClickable(true);
    GestureDetector.SimpleOnGestureListener simpleOnGestureListener = new GestureDetector.SimpleOnGestureListener() {
        @Override
        public boolean onSingleTapUp(MotionEvent e) {
            StringBuilder stringBuilder = new StringBuilder(data.getmTagsrchref());
            //点击bannerview如果是主播则跳转到直播界面
            if(isNumeric(stringBuilder.substring(stringBuilder.length()-8))){
                PublicAPI.requestStarByID(stringBuilder.substring(stringBuilder.length()-8)).execute(new BaseRequestCallback<RoomListResult>() {
                    @Override
                    public void onRequestSucceed(RoomListResult result) {
                        // TODO Auto-generated method stub
                        roomdata = result.getDataList().get(0);
                        Utils.autoEnterLiveOrZone(getContext(), roomdata, LiveActivity.class, NewOtherUserZoneActivity.class);
                    }

                    @Override
                    public void onRequestFailed(RoomListResult result) {
                        // TODO Auto-generated method stub
                        PromptUtils.showToast("网络连接错误，请检查网络后重试", 1);
                    }
                });
            }else if (stringBuilder.substring(stringBuilder.length()-5).equals("xhtml")) {
                if (LoginUtils.isAlreadyLogin() && UserInfoUtils.getAccessToken() != null) {
                    System.out.println(stringBuilder);
                    Intent intent = new Intent(getContext(), BannerActivity.class);
                    intent.putExtra(BannerIntentKey.INTENT_CLICK_URL, stringBuilder.toString()+"?"+"access_token=" +UserInfoUtils.getAccessToken());
                    intent.putExtra(BannerIntentKey.INTENT_TITLE, data.getmName());
                    getContext().startActivity(intent);
                }else {
                    Intent intent = new Intent(getContext(), BannerActivity.class);
                    intent.putExtra(BannerIntentKey.INTENT_CLICK_URL, stringBuilder.toString());
                    intent.putExtra(BannerIntentKey.INTENT_TITLE, data.getmName());
                    getContext().startActivity(intent);
                }

            }else{
                 if (LoginUtils.isAlreadyLogin() && UserInfoUtils.getAccessToken() != null) {
                     stringBuilder.append(stringBuilder.indexOf("?") == -1 ? "?" : "&")
                             .append("access_token=").append(UserInfoUtils.getAccessToken());
                 }
                 Intent intent = new Intent(getContext(), BannerActivity.class);
                 intent.putExtra(BannerIntentKey.INTENT_CLICK_URL, stringBuilder.toString());
                 intent.putExtra(BannerIntentKey.INTENT_TITLE, data.getmName());
                 getContext().startActivity(intent);
            }

            return super.onSingleTapUp(e);
        }
    };
    final GestureDetector gestureDetector = new GestureDetector(getContext(), simpleOnGestureListener);
    imageView.setOnTouchListener(new View.OnTouchListener() {
        @Override
        public boolean onTouch(View v, MotionEvent event) {
            return gestureDetector.onTouchEvent(event);
        }
    });
    imageView.setImageBitmap(bitmap);
    imageView.setLayoutParams(new ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, DisplayUtils.dp2px(BANNER_HEIGHT)));
    imageView.setScaleType(ImageView.ScaleType.FIT_XY);
    imageView.setBackgroundColor(getResources().getColor(R.color.transparent));
    mBannerView.addView(imageView);
    mBannerView.setEnableAutoScroll(true);

    //设置在BannerView条目数为1时不可滑动
    if(mBannerView.getChildCount() == 1){
        mBannerView.setEnableManualScroll(false);
    }else{
        mBannerView.setEnableManualScroll(true);
    }
}
public boolean isNumeric(String str){ 
    Pattern pattern = Pattern.compile("[0-9]*"); 
    Matcher isNum = pattern.matcher(str);
    if( !isNum.matches() ){
       return false; 
    } 
    return true; 
}
}

自动向左滚动控件

- 设置拖延时间，默认3s

package com.rednovo.weibo.widget.zoomview;

import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Paint;
import android.graphics.Rect;
import android.os.Handler;
import android.util.AttributeSet;
import android.view.*;
import android.view.animation.DecelerateInterpolator;
import android.widget.FrameLayout;
import android.widget.Scroller;

/**
 * 自动向左滚动控件
 *
 * @author ll
 * @version 2.0.0
 * @since 2012-8-24
 */
public class HorizonScrollableViewGroup extends FrameLayout {

private static final String LOG_TAG = "ScrollableViewGroup";
private static final long DELAY = 3000;
private static final int INVALID_SCREEN = -1;
private static final int TOUCH_STATE_REST = 0;
private static final int TOUCH_STATE_SCROLLING = 1;
private static final int SNAP_VELOCITY = 500;

private int mDefaultScreen;
private int mCurrentScreen;
private int mNextScreen = INVALID_SCREEN;

private boolean mEnableRuntimeScrollMotion = true;
// private int mMaximumVelocity;
private Scroller mScroller;
private int mTouchState;
private float mLastMotionX;
private float mLastMotionY;
private int mTouchSlop;
private boolean mAllowLongPress;
private VelocityTracker mVelocityTracker;

private int mPaintFlag = 0;

private OnCurrentViewChangedListener mOnCurrentViewChangedListener;
private boolean mIsTouch = false;

private boolean mEnableAutoScroll = true;
private static final int WHAT_AUTO_SCROLL = 1;

private boolean mEnableManualScroll = true;

/**
 * 设置图片是否允许自动滚动显示
 * @param enableAutoScroll true: 允许, false : 不允许
 */
public void setEnableAutoScroll(boolean enableAutoScroll) {
    mEnableAutoScroll = enableAutoScroll;
    mHandler.removeMessages(WHAT_AUTO_SCROLL);
    if (mEnableAutoScroll) {
        mHandler.sendEmptyMessageDelayed(WHAT_AUTO_SCROLL, DELAY);
    }
}

private Handler mHandler = new Handler() {
    public void handleMessage(android.os.Message msg) {
        if (!mIsTouch && getChildCount() > 1) {
            snapToScreen(mCurrentScreen + 1);
        }

        if (!mEnableAutoScroll) {
            return;
        }

        mHandler.removeMessages(WHAT_AUTO_SCROLL);
        mHandler.sendEmptyMessageDelayed(WHAT_AUTO_SCROLL, DELAY);
    }
};

/**
 * 页面切换的回调接口
 * @author ll
 * @version 2.0.0
 * @since 2012-8-24
 */
public interface OnCurrentViewChangedListener {
    /**
     * 当前页面切换的回调接口.
     *
     * @param view 要切换的View
     * @param currentScreen 当前屏幕
     */
    public void onCurrentViewChanged(View view, int currentScreen);
};

/**
 * 构造函数
 * @param context 上下文
 */
public HorizonScrollableViewGroup(Context context) {
    super(context);
    initViewGroup();
}

/**
 * 构造函数，支持布局
 * @param context 上下我
 * @param attrs 属性组
 */
public HorizonScrollableViewGroup(Context context, AttributeSet attrs) {
    super(context, attrs);
    initViewGroup();
}

/**
 * 构造函数，支持布局
 * @param context 上下我
 * @param attrs 属性组
 * @param defStyle 风格
 */
public HorizonScrollableViewGroup(Context context, AttributeSet attrs, int defStyle) {
    super(context, attrs, defStyle);
    initViewGroup();
}

/*
 * (non-Javadoc)
 *
 * @see android.view.ViewGroup#onLayout(boolean, int, int, int, int)
 */
@Override
protected void onLayout(boolean changed, int l, int t, int r, int b) {
    int childLeft = 0;
    final int count = getChildCount();
    for (int i = 0; i < count; i++) {
        final View child = getChildAt(i);
        if (child.getVisibility() != View.GONE) {
            final int childWidth = child.getMeasuredWidth();
            child.layout(childLeft, 0, childLeft + childWidth, child.getMeasuredHeight());
            childLeft += childWidth;
        }
    }
}

/**
 * Initializes various states for this viewgroup.
 */
private void initViewGroup() {
    mScroller = new Scroller(getContext(), new DecelerateInterpolator());
    mCurrentScreen = mDefaultScreen;
    final ViewConfiguration configuration = ViewConfiguration.get(getContext());
    mTouchSlop = configuration.getScaledTouchSlop() << 1; // 2
    // mMaximumVelocity = configuration.getScaledMaximumFlingVelocity();

// mHandler.sendEmptyMessageDelayed(WHAT_AUTO_SCROLL, DELAY);
}

/**
 * 是否默认View显示.
 *
 * @return boolean
 */
public boolean isDefaultViewShowing() {
    return mCurrentScreen == mDefaultScreen;
}

/**
 * 获取当前View id.
 *
 * @return int
 */
public int getCurrentView() {
    return mCurrentScreen;
}

/**
 * 设置是否允许手动滑动
 * @param enable  enable
 */
public void setEnableManualScroll(boolean enable) {
    mEnableManualScroll = enable;
}

/**
 * 设置当前View.
 *
 * @param currentView 当前View id
 */
public void setCurrentView(int currentView) {
    // snapToScreen(currentView);
    mCurrentScreen = Math.max(0, Math.min(currentView, getChildCount() - 1));
    scrollTo(mCurrentScreen * getWidth(), 0);
    if (mOnCurrentViewChangedListener != null) {
        mOnCurrentViewChangedListener.onCurrentViewChanged(this, mCurrentScreen);
    }

    invalidate();
}

/*
 * (non-Javadoc)
 *
 * @see android.view.View#computeScroll()
 */
@Override
public void computeScroll() {
    if (mScroller.computeScrollOffset()) {

// FIXED computeScroll;
final int currx = mScroller.getCurrX(), curry = mScroller.getCurrY(), scrx = getScrollX(), scry = getScrollY();

        if (currx != scrx || curry != scry) {
            scrollTo(mScroller.getCurrX(), mScroller.getCurrY());
        } else {
            invalidate();
        }
    } else if (mNextScreen != INVALID_SCREEN) {
        mCurrentScreen = Math.max(0, Math.min(mNextScreen, getChildCount() - 1));
        mNextScreen = INVALID_SCREEN;
        clearChildrenCache();
        final int scrx = getScrollX(), scry = getScrollY(), mCurrentScrollX = mCurrentScreen * getWidth();
        if (scrx != mCurrentScrollX) {
            scrollTo(mCurrentScrollX, scry);
        }
        if (mOnCurrentViewChangedListener != null) {
            mOnCurrentViewChangedListener.onCurrentViewChanged(this, mCurrentScreen);
        }
    }
}

/*
 * (non-Javadoc)
 *
 * @see android.view.ViewGroup#dispatchDraw(android.graphics.Canvas)
 */
@Override
protected void dispatchDraw(Canvas canvas) {
    if (getChildCount() == 0) {
        return;
    }
    boolean fastDraw = mTouchState != TOUCH_STATE_SCROLLING && mNextScreen == INVALID_SCREEN;
    // If we are not scrolling or flinging, draw only the current screen
    if (fastDraw) {
        View child = getChildAt(mCurrentScreen);
        if (child != null) {
            drawChild(canvas, getChildAt(mCurrentScreen), getDrawingTime());
        }
    } else {
        final long drawingTime = getDrawingTime();
        // If we are flinging, draw only the current screen and the target
        // screen
        if (mNextScreen >= 0 && mNextScreen < getChildCount() && (Math.abs(mCurrentScreen - mNextScreen) == 1 || mPaintFlag != 0)) {
            final View viewCurrent = getChildAt(mCurrentScreen), viewNext = getChildAt(mNextScreen);
            if (viewCurrent != null) {
                drawChild(canvas, viewCurrent, drawingTime);
                if (mPaintFlag == 0) {
                    drawChild(canvas, viewNext, drawingTime);
                } else {
                    Paint paint = new Paint();
                    if (mPaintFlag < 0) {
                        if (viewNext.getDrawingCache() != null) {
                            canvas.drawBitmap(viewNext.getDrawingCache(), -viewNext.getWidth(), viewNext.getTop(), paint);
                        }
                    } else {
                        if (viewNext.getDrawingCache() != null) {
                            canvas.drawBitmap(viewNext.getDrawingCache(), getWidth() * getChildCount(), viewNext.getTop(), paint);
                        }
                    }
                }
            }
        } else {
// If we are scrolling, draw all of our children
            final int count = getChildCount();
            for (int i = 0; i < count; i++) {
                drawChild(canvas, getChildAt(i), drawingTime);
            }

            if (mPaintFlag != 0) {
                final View viewNext;
                Paint paint = new Paint();
                if (mPaintFlag < 0) {
                    viewNext = getChildAt(getChildCount() - 1);
                    if (viewNext.getDrawingCache() != null) {
                        canvas.drawBitmap(viewNext.getDrawingCache(), -viewNext.getWidth(), viewNext.getTop(), paint);
                    }
                } else {
                    viewNext = getChildAt(0);
                    if (viewNext.getDrawingCache() != null) {
                        canvas.drawBitmap(viewNext.getDrawingCache(), getWidth() * getChildCount(), viewNext.getTop(), paint);
                    }

                }
            }
        }
    }
}

/*
 * (non-Javadoc)
 *
 * @see
 * android.view.ViewGroup#requestChildRectangleOnScreen(android.view.View,
 * android.graphics.Rect, boolean)
 */
@Override
public boolean requestChildRectangleOnScreen(View child, Rect rectangle, boolean immediate) {
    int screen = indexOfChild(child);
    if (screen != mCurrentScreen || !mScroller.isFinished()) {
        snapToScreen(screen);
        return true;
    }
    return false;
}

/*
 * (non-Javadoc)
 *
 * @see android.view.ViewGroup#onRequestFocusInDescendants(int,
 * android.graphics.Rect)
 */
@Override
protected boolean onRequestFocusInDescendants(int direction, Rect previouslyFocusedRect) {
    int focusableScreen;
    if (mNextScreen != INVALID_SCREEN) {
        focusableScreen = mNextScreen;
    } else {
        focusableScreen = mCurrentScreen;
    }
    //getChildAt(focusableScreen).requestFocus(direction, previouslyFocusedRect);
    return false;
}

/*
 * (non-Javadoc)
 *
 * @see android.view.ViewGroup#dispatchUnhandledMove(android.view.View, int)
 */
@Override
public boolean dispatchUnhandledMove(View focused, int direction) {
    if (direction == View.FOCUS_LEFT) {
        if (getCurrentView() > 0) {
            snapToScreen(getCurrentView() - 1);
            return true;
        }
    } else if (direction == View.FOCUS_RIGHT) {
        if (getCurrentView() < getChildCount() - 1) {
            snapToScreen(getCurrentView() + 1);
            return true;
        }
    }
    return super.dispatchUnhandledMove(focused, direction);
}

/*
 * (non-Javadoc)
 *
 * @see
 * android.view.ViewGroup#onInterceptTouchEvent(android.view.MotionEvent)
 */
@Override
public boolean onInterceptTouchEvent(MotionEvent ev) {

    final int action = ev.getAction();

    if ((action == MotionEvent.ACTION_MOVE) && (mTouchState != TOUCH_STATE_REST)) {
        return true;
    }

    final float x = ev.getX();
    final float y = ev.getY();

    switch (action) {
        case MotionEvent.ACTION_MOVE:
            final int xDiff = (int) Math.abs(x - mLastMotionX);
            final int yDiff = (int) Math.abs(y - mLastMotionY);

            final int touchSlop = mTouchSlop;
            boolean xMoved = xDiff > touchSlop;
            boolean yMoved = yDiff > touchSlop;

            if (xMoved || yMoved) {
                if (xMoved) {
                    // Scroll if the user moved far enough along the X axis
                    if (mEnableRuntimeScrollMotion) {
                        mTouchState = TOUCH_STATE_SCROLLING;
                        enableChildrenCache();
                    } else if (xDiff > getWidth() >> 3) {
                        mTouchState = TOUCH_STATE_SCROLLING;
                    } else {
                        mTouchState = TOUCH_STATE_REST;
                    }
                }
                // Either way, cancel any pending longpress
                if (mAllowLongPress) {
mAllowLongPress = false;
// Try canceling the long press. It could also have been
// scheduled
// by a distant descendant, so use the mAllowLongPress flag
// to block
// everything
                    final View currentScreen = getChildAt(mCurrentScreen);
                    currentScreen.cancelLongPress();
                }
            }
            break;

        case MotionEvent.ACTION_DOWN:
            // Remember location of down touch
            mLastMotionX = x;
            mLastMotionY = y;
            mAllowLongPress = true;
        /*
         * If being flinged and user touches the screen, initiate drag;
         * otherwise don't. mScroller.isFinished should be false when being
         * flinged.
         */
            mTouchState = mScroller.isFinished() ? TOUCH_STATE_REST : TOUCH_STATE_SCROLLING;

            mIsTouch = true;
            break;

        case MotionEvent.ACTION_CANCEL:
        case MotionEvent.ACTION_UP:
            mTouchState = TOUCH_STATE_REST;
            mAllowLongPress = false;

            mIsTouch = false;
            mHandler.removeMessages(WHAT_AUTO_SCROLL);
            mHandler.sendEmptyMessageDelayed(WHAT_AUTO_SCROLL, DELAY);
            break;

        default:
            break;
    }

    if (action == MotionEvent.ACTION_DOWN
            || action == MotionEvent.ACTION_MOVE) {
        getParent().requestDisallowInterceptTouchEvent(true);
    }

    return mTouchState != TOUCH_STATE_REST;
}

void enableChildrenCache() {
    final int count = getChildCount();
    for (int i = 0; i < count; i++) {
        final View layout = getChildAt(i);
        layout.setDrawingCacheEnabled(true);
        if (layout instanceof ViewGroup) {
            ((ViewGroup) layout).setAlwaysDrawnWithCacheEnabled(true);
        }
    }
}

void clearChildrenCache() {
    mPaintFlag = 0;
    final int count = getChildCount();
    for (int i = 0; i < count; i++) {
        final View layout = getChildAt(i);
        if (layout instanceof ViewGroup) {
            ((ViewGroup) layout).setAlwaysDrawnWithCacheEnabled(false);
        }
    }
}

/*
 * (non-Javadoc)
 *
 * @see android.view.View#onTouchEvent(android.view.MotionEvent)
 */
@Override
public boolean onTouchEvent(MotionEvent event) {//这里改
    if (getChildCount() == 0) {
        return super.onTouchEvent(event);
    }

    if (mVelocityTracker == null) {
        mVelocityTracker = VelocityTracker.obtain();
    }
    mVelocityTracker.addMovement(event);

    final int action = event.getAction();
    final float x = event.getX();
    switch (action) {
        case MotionEvent.ACTION_DOWN:
            mIsTouch = true;
            mScroller.abortAnimation();

            mLastMotionX = x;
            break;
        case MotionEvent.ACTION_MOVE:
            if (mEnableManualScroll && mEnableRuntimeScrollMotion && mTouchState == TOUCH_STATE_SCROLLING) {
                // Scroll to follow the motion event
                int deltaX = (int) (mLastMotionX - x);
                mLastMotionX = x;

                if (deltaX < 0) {
                    if (getScrollX() <= 0) {
                        mPaintFlag = -1;
                    }
                    scrollBy(deltaX, 0);
                } else if (deltaX > 0) {
                    int availableToScroll = getChildAt(getChildCount() - 1).getRight() - getScrollX() - getWidth();
                    if (availableToScroll <= 0) {
                        mPaintFlag = 1;
                        availableToScroll += getWidth() << 1;
                    }
                    if (availableToScroll > 0) {
                        scrollBy(Math.min(availableToScroll, deltaX), 0);
                    }
                }
            }
            mTouchState = TOUCH_STATE_SCROLLING;
            break;
        case MotionEvent.ACTION_UP:
        case MotionEvent.ACTION_CANCEL:
            if (mEnableManualScroll && mTouchState == TOUCH_STATE_SCROLLING) {
                final VelocityTracker velocityTracker = mVelocityTracker;
                velocityTracker.computeCurrentVelocity(1000);

                int velocityX = (int) velocityTracker.getXVelocity();

                if (velocityX > SNAP_VELOCITY) {
                    // Fling hard enough to move left
                    snapToScreen(mCurrentScreen - 1);
                } else if (velocityX < -SNAP_VELOCITY) {
                    // Fling hard enough to move right
                    snapToScreen(mCurrentScreen + 1);
                } else {
                    snapToDestination();
                }

                if (mVelocityTracker != null) {
                    mVelocityTracker.recycle();
                    mVelocityTracker = null;
                }
            }
            mTouchState = TOUCH_STATE_REST;
            mIsTouch = false;
            mHandler.removeMessages(WHAT_AUTO_SCROLL);
            mHandler.sendEmptyMessageDelayed(WHAT_AUTO_SCROLL, DELAY);
            break;
        default:
            break;
    }

    if (action == MotionEvent.ACTION_DOWN
            || action == MotionEvent.ACTION_MOVE) {
        getParent().requestDisallowInterceptTouchEvent(true);
    }

    return true;
}

private void snapToDestination() {
    final int screenWidth = getWidth();
    final int scrollWidth = getScrollX() + (screenWidth >> 1);
    final int viewCount = getChildCount();
    final int whichScreen;
    if (scrollWidth < 0) {
        whichScreen = -1;
    } else if (scrollWidth > screenWidth * viewCount) {
        whichScreen = viewCount;
    } else {
        whichScreen = screenWidth > 0 ? (getScrollX() + (screenWidth / 2)) / screenWidth : 0;
    }
    snapToScreen(whichScreen);
}

/**
 * 跳转到指定屏幕.
 *
 * @param whichScreen 屏幕Id
 */
public void snapToScreen(int whichScreen) {
    if (!mScroller.isFinished()) {
        mScroller.abortAnimation();
    }

    boolean changingScreens = whichScreen != mCurrentScreen;

    final int viewCount = getChildCount() - 1;

    final int delta = whichScreen * getWidth() - getScrollX();

    if (!changingScreens && delta == 0) {
        return;
    }

    enableChildrenCache();

    if (whichScreen < 0) {
        whichScreen = viewCount;
        mPaintFlag = -1; // next screen should be painted before current
    } else if (whichScreen > viewCount) {
        whichScreen = 0;
        mPaintFlag = 1;
    } else {
        mPaintFlag = 0;
    }

    mNextScreen = whichScreen;

    View focusedChild = getFocusedChild();
    if (focusedChild != null && changingScreens && focusedChild == getChildAt(mCurrentScreen)) {
        focusedChild.clearFocus();
    }

    mScroller.startScroll(getScrollX(), 0, delta, 0, Math.abs(delta));

    invalidate();
}

/**
 * 往左滑动.
 *
 */
public void scrollLeft() {
    if (mNextScreen == INVALID_SCREEN && mCurrentScreen > 0 && mScroller.isFinished()) {
        snapToScreen(mCurrentScreen - 1);
    }
}

/**
 * 往右滑动.
 *
 */
public void scrollRight() {
    if (mNextScreen == INVALID_SCREEN && mCurrentScreen < getChildCount() - 1 && mScroller.isFinished()) {
        snapToScreen(mCurrentScreen + 1);
    }
}

/**
 * 滚动到默认屏幕.
 *
 */
public void moveToDefaultScreen() {
    snapToScreen(mDefaultScreen);
    getChildAt(mDefaultScreen).requestFocus();
}

/**
 * 判断滚动是否结束.
 *
 * @return boolean
 */
public boolean isScrollFinish() {
    return (mEnableRuntimeScrollMotion && mTouchState != TOUCH_STATE_SCROLLING && mNextScreen == INVALID_SCREEN)
            || (!mEnableRuntimeScrollMotion && mScroller.isFinished());
}

/**
 * get当前View改变的接口.
 *
 * @return OnCurrentViewChangedListener
 */
public OnCurrentViewChangedListener getOnCurrentViewChangedListener() {
    return mOnCurrentViewChangedListener;
}

/**
 * 设置当前View改变的接口.
 *
 * @param listener 当前View改变的接口
 */
public void setOnCurrentViewChangedListener(OnCurrentViewChangedListener listener) {
    this.mOnCurrentViewChangedListener = listener;
}

/**
 * 设置是否允许实时滚动.
 *
 * @param enable boolean
 */
public void setEnableRuntimeScrollMotion(boolean enable) {
    mEnableRuntimeScrollMotion = enable;
}

/**
 * 判断是否可以实时滚动.
 *
 * @return boolean
 */
public boolean isEnableRuntimeScrollMotion() {
    return mEnableRuntimeScrollMotion;
}

@Override
protected void onDetachedFromWindow() {
    super.onDetachedFromWindow();

    mHandler.removeMessages(WHAT_AUTO_SCROLL);
}

/**
 * 取消自动滚动
 */
public void stopAutoScroll() {
    mHandler.removeMessages(WHAT_AUTO_SCROLL);
}
}

添加到主布局

<*.*BannerView
android:id="@+id/id_main_banner_view"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:visibility="gone"/>